深深深度度度学学学习习习在在在图图图像像像识识识别别别中中中的的的应应应用用用
戚戚戚锦锦锦秀秀秀
院（系）：航天学院控制科学与工程系 专 业： 自动化
学 号： 1110410427 指导教师： 杨旭东
2015年6月29日
毕毕毕业业业设设设计计计（（（论论论文文文）））
题题题 目目目：：：深深深度度度学学学习习习在在在图图图像像像识识识别别别中中中的的的应应应用用用
专专专 业业业 自自自动动动化化化
学学学 号号号 1110410427
学学学 生生生 戚戚戚锦锦锦秀秀秀
指指指导导导教教教师师师 杨杨杨旭旭旭东东东
答答答辩辩辩日日日期期期 2015年年年6月月月29日日日
哈尔滨工业大学本科毕业设计（论文）
摘 要
深度学习是近年来人工智能研究领域的一个热点，这个机器学习的分支以
全连接的深度置信网络和局部连接的卷积神经网络为代表，融合概率图模型、
马尔可夫链蒙特卡罗方法等多个技术，其基于大规模数据而训练出的模型在
声音识别、图像识别等众多领域中获得了突破性成果。本文主要研究了深度置
信网络及卷积神经网络的工作原理，并在MNIST与CIFAR数据集上进行模型的
训练，利用GPU与CPU的异构计算在MNIST数据集上取得了98.9%的识别正确率，
在CIFAR-10数据集上取得了62%的识别正确率。在本文中，我们还讨论了包括降
维在内的多个神经网络设计技巧以及实验中发现的一些现象。
关键词： 深度学习；受限玻尔兹曼机；深度置信网络；卷积神经网络；MCMC；
GPU计算
- I -
哈尔滨工业大学本科毕业设计（论文）
Abstract
Deep learning as a branch of machine learning which is represented by a full con-
nected neural network named Deep Belief Networks as well as a local connected network
named Convolutional Neural Networks has drawn lots of attention in the field of artificial
intelligence. Multiple technologies like probabilistic graphical models and Markov Chain
Monte Carlo methods have integrated into deep learning nowadays and they help deep
learning make a great breakthrough in many AI tasks such as speech and image recogni-
tion by training models based on large-scale data. This paper focus on the principles of
Deep Belief Networks and Convolution Neural Network s, and we trained some models
on the MNIST and CIFAR-10 dataset using DBNs or CNNs. As a result, we achieved
98.9% recognition accuracy on MNIST dataset and 62% recognition accuracy on CIFAR-
10 dataset with the help of GPU&CPU-based heterogeneous computing. A number of
phenomena found in our experiments and tricks of designing the neural networks, includ-
ing dimensionality reduction, will also be discussed in this paper.
Keywords: deep learning, restricted boltzmann machines, deep belief networks, convo-
lutional neural networks, Markov chain Monte Carlo, GPU computation
- II -
哈尔滨工业大学本科毕业设计（论文）
目 录
摘 要............................................................................................. I
ABSTRACT ...................................................................................... II
第 1 章 绪论 .................................................................................... 1
1.1 课题来源及研究的目的和意义 .......................................................... 1
1.2 国内外在该方向的研究现状及分析.................................................... 3
1.2.1 神经网络与深度学习的发展状况................................................. 3
1.2.2 感知器时期............................................................................... 3
1.2.3 反向传播时期 ........................................................................... 5
1.2.4 深度学习时期 ........................................................................... 5
1.3 深度学习在人工智能上的应用 .......................................................... 6
1.3.1 语音识别 .................................................................................. 6
1.3.2 图像识别 .................................................................................. 6
1.3.3 自然语言处理 ........................................................................... 7
第 2 章 控制论与机器学习 .................................................................. 8
2.1 白盒模型与经典控制论 .................................................................... 8
2.2 灰盒模型与系统辨识........................................................................ 9
2.3 黑盒模型与统计机器学习................................................................. 9
2.4 本章小结 ........................................................................................ 11
第 3 章 受限玻尔兹曼机 ..................................................................... 12
3.1 伊辛模型 ........................................................................................ 12
3.2 玻尔兹曼机..................................................................................... 13
3.3 受限玻尔兹曼机 .............................................................................. 14
3.4 本章小结 ........................................................................................ 19
第 4 章 马尔可夫链蒙特卡罗方法 ......................................................... 20
4.1 蒙塔卡罗方法核心思想 .................................................................... 20
4.2 舍弃采样 ........................................................................................ 21
4.3 重要性采样..................................................................................... 25
4.4 马尔可夫链..................................................................................... 27
4.5 Metropolis-Hastings算法 ................................................................... 30
- III -
哈尔滨工业大学本科毕业设计（论文）
4.6 Gibbs采样....................................................................................... 33
4.7 对比离差 ........................................................................................ 35
4.8 本章小结 ........................................................................................ 36
第 5 章 深度置信网络 ........................................................................ 37
5.1 神经网络组成及表达能力................................................................. 37
5.1.1 神经元 ..................................................................................... 37
5.1.2 逻辑表达 .................................................................................. 39
5.2 神经网络的前馈 .............................................................................. 40
5.2.1 神经激活 .................................................................................. 41
5.3 分类器............................................................................................ 45
5.3.1 平方误差分类器 ........................................................................ 45
5.3.2 softmax分类器........................................................................... 46
5.4 神经网络的反馈 .............................................................................. 48
5.4.1 分类器参数校正 ........................................................................ 49
5.4.2 误差传播 .................................................................................. 51
5.5 深度置信网络.................................................................................. 53
5.6 本章小结 ........................................................................................ 56
第 6 章 卷积神经网络 ........................................................................ 57
6.1 卷积神经网络综述........................................................................... 57
6.2 卷积神经网络的前馈........................................................................ 59
6.2.1 卷积......................................................................................... 59
6.2.2 采样......................................................................................... 62
6.2.3 分类器 ..................................................................................... 63
6.3 卷积神经网络的反馈........................................................................ 63
6.3.1 分类器误差传播 ........................................................................ 63
6.3.2 采样层误差传播 ........................................................................ 64
6.3.3 卷积层误差传播 ........................................................................ 64
6.4 本章小结 ........................................................................................ 65
第 7 章 神经网络的设计技巧 ............................................................... 66
7.1 数据预处理..................................................................................... 66
7.1.1 降维......................................................................................... 67
7.1.2 扩容......................................................................................... 74
- IV -
哈尔滨工业大学本科毕业设计（论文）
7.2 训练技巧 ........................................................................................ 75
7.2.1 学习率 ..................................................................................... 75
7.2.2 动量项 ..................................................................................... 77
7.2.3 权衰减 ..................................................................................... 78
7.3 编码技巧 ........................................................................................ 79
7.3.1 面向对象技术 ........................................................................... 79
7.3.2 梯度校验 .................................................................................. 80
7.4 本章小结 ........................................................................................ 81
第 8 章 GPU计算 .............................................................................. 82
8.1 GPU体系结构.................................................................................. 82
8.2 CUDA ............................................................................................ 85
8.3 Cudamat.......................................................................................... 87
8.4 Gnumpy .......................................................................................... 87
8.5 PyCUDA......................................................................................... 88
8.6 Caffe .............................................................................................. 89
8.7 本章小结 ........................................................................................ 90
第 9 章 实验现象及讨论 ..................................................................... 91
9.1 数据集简介..................................................................................... 91
9.1.1 MNIST ..................................................................................... 91
9.1.2 CIFAR-10 ................................................................................. 92
9.2 深度置信网络在MNIST数据集上的性能............................................. 93
9.3 卷积神经网络在MNIST数据集上的性能............................................. 96
9.4 卷积神经网络在CIFAR-10数据集上的性能......................................... 98
9.5 使用Caffe实现的CIFAR-10数据集训练 ............................................... 101
9.6 本章小结 ........................................................................................ 103
结 论.............................................................................................104
参考文献..........................................................................................105
原创性声明.......................................................................................109
致 谢.............................................................................................110
附录 A 深度置信网络源代码 ...............................................................111
附录 B 卷积神经网络源代码................................................................127
- V -
哈尔滨工业大学本科毕业设计（论文）
第 1 章 绪论
1.1 课题来源及研究的目的和意义
机器学习以及模式识别均属于人工智能范畴，机器学习源自于计算机科学，
模式识别源自于工程学，尽管这两者源自于不同的背景，但这两者可以认为是同
一个领域下的不同描述
[1]
。自计算机出生以来，人们一直都在探索一个问题：机
器能否实现智能？ 早期的一部分研究人员试图从事物的机理出发，寻找模式背后
的规律，比如在自然语言处理领域，最初人们从分析语法语义开始，企图让机器
理解自然语言，并能实现一些类似于翻译之类的工作，但失败了，一个重要的原
因是自然语言的规则错综复杂，要摸清其运作机理哪怕以目前的学科水平来看也
几乎是难以实现的。
在随后的二三十年里，人类乐观地认为可以找到自然语言背后的运作机理，
但实验结果都不尽人意，机理建模这条道路看起来像是一条死胡同。到了上世纪
九十年代，统计机器学习开始成为主流，经过二十多年的高速发展，目前基于统
计的建模方法成为了主流，而统计机器学习取得的成就远大于上世纪六十年到到
九十年代取得的成果，当然这也不排除计算机运算能力的影响。
相比于机理建模，统计机器学习的出发点是从数据出发，建立一个可以刻画
已有数据的概率分布，如果将机理建模比作是牛顿力学，那么统计学习就相当于
统计力学。事实上，从统计的角度上去解决人工智能问题并不是一个新的想法，
早在上世纪七十年代统计学习就已经开始出现。统计机器学习使我们不再需要研
究模式背后的运作机理，并且通过它可以实现通用学习。如果说一个事物背后有
一个函数决定了它的特性，那么我们不再需要研究这个函数究竟是什么形式，只
要有足够多的数据，通过统计方法，选取恰当的模型，我们便可以在一定程度上
拟合出这个函数，尽管我们拟合出的函数在大多数情况下都不等价于事物的本质
函数，但如果它能在可允许的误差范围内正常工作，这就足够了。
统计机器学习方法的出现，使得工作重点转为寻找合适的模型上，事实上这
也是统计机器学习其本质：经验风险最小化
[2]
。也就是说，我们应该如何寻找一
个合适的模型，使得测试误差最小化？ 由于模型的选取取决于设计者的意愿，我
们既可以选择一个简单的模型，比如线性函数，也可以选择一个复杂的函数，比
如高次多项式函数，但是实际问题中，大多数情况下，如果使用简单的线性函数，
- 1 -
哈尔滨工业大学本科毕业设计（论文）
数据在低维空间中是不可分的，为了使数据变得线性可分，我们可以将数据由低
维空间映射到高维空间中，但这种方案引入了庞大的运算以至于计算机难以计算，
我们称这种现象为“维数灾难”，即随着维数的线性增加，计算量指数地增大。
又或者，我们一开始就不使用线性函数而使用较为复杂的函数比如高斯函数实现
非线性分割，但由于我们不知道数据的分布形式，也难以将实际问题中的高维数
据可视化，所以除非我们有关于数据分布的先验知识，否则并不知道我们选取的
这个复杂的函数是否是合理的。
为了解决维数灾难，我们可以使用核函数，在低维空间中直接计算高维空间
返回的结果，避开了高维空间的运算，这种方法也被称之为核方法，比如上世纪
九十年代提出的支撑向量机（kernel-SVM）就是一种使用了核方法的分类器。而
如果为了避免复杂函数的选取问题，我们可以使用神经网络。神经网络基于一种
假说—–智能源自于单一的算法，在神经网络中，我们只需选取激活函数，即所谓
的“单一的算法”，然后训练网络的连接权值，从而跳过函数选取步骤。
关于神经网络的表达能力方面，在理论上，柯尔莫格洛夫（Kolmogorov）证
明了：只要给予足够多的神经元、合适的激活函数以及恰当的权值，任何从输入
到输出的连续映射函数都可以用三层神经网络实现。如果从傅里叶理论上看，则
相当于：任何连续函数都可以用足够多的谐波来逼近
[3]
。
柯 尔 莫 格 洛 夫 的 定 理 说 明 了 神 经 网 络 的 表 达 能 力 与 神 经 网 络 的 层
数 无 关， 只 与 神 经 元 的 数 目 有 关， 似 乎 我 们 没 有 必 要 加 深 网 络 的 深 度，
但Hastad与Goldmann在1991年提出了以下定理
[4]
定理 1.1 为了计算一个函数 f
k
∈ F
k,N
，深度为k − 1的单调加权门限电路所需的规模
至少为2
cN
，其中常数c > 0，N > N
0
由于神经网络与电路的联系十分密切，如果将定理1.1 转化为神经网络的术
语，则为：深度为k的神经网络所能表达的函数，深度为k − 1的神经网络为了达到
同样的效果至少需要引入指数级规模的节点。
倘若从大脑科学的角度思考，我们已经知道，哺乳动物的大脑是一个深度结
构，它可以将输入的模式在多个层次上进行抽象再表达，而每个层次对应着皮层
的不同区域。以大脑在视觉系统上的工作机理为例，其工作过程依次经过如下几
个步骤：边界检测、基本外形建立、逐渐地完善更为详尽外形
[5]
。
在定理1.1以及大脑科学的启发下，我们对深度神经网络充满信心，因此神经
网络研究人员花费数十年致力于深度神经网络的研究，然而直到2006年之前
[6, 7]
，
我们都难以找到一个较好的算法来训练深度神经网络，其原因一方面是深度神经
网络局部最优解繁多，导致深度神经网络比浅层神经网络更容易陷入局部最小值，
- 2 -
哈尔滨工业大学本科毕业设计（论文）
另一方面则是受计算机运算能力的限制
[8]
。
2006年Hinton提出了受限玻尔兹曼机以及深度置信网络的训练方法，通过贪
婪逐层地训练
[9]
，成功地实现了第一个深度神经网络，随后深度神经网络又发展
处深度卷积网络、稀疏自动编码机
[10]
等方法，这些方法被统称为深度学习。目
前，深度学习已应用到分类、回归、聚类、降维
[11]
、自然语言处理、信息检索、
机器人学等任务中，且在某些领域中其应用效果已远远超越以前的机器学习方
法。
1.2 国内外在该方向的研究现状及分析
2015年5月，Nature为纪念人工智能60周年开辟了”人工智能与机器人”专题，
回顾了过去的研究历程与当今的研究热点，其中深度学习作为一个热点被加以介
绍
[12]
。目前深度学习在国内外都受到广泛关注，新的深度学习算法源源不断地被
提出，在不久的将来，深度学习将会取得更多的成功。
1.2.1 神经网络与深度学习的发展状况
数十年来，神经网络研究人员在神经科学上付出了巨大心血，其研究之深入，
范围之广，内容之繁杂是别的机器学习方法所难以企及的。我们今天看到的深度
学习只是神经计算科学中的冰山一角，在它之下，是几十年探索积累起来的失败
经验，这些模型中不乏观点新颖却无法工作的模型。这么多年来研究人员试图将
神经网络理论化，然而到目前为止这项工作依然没有实现。
1.2.2 感知器时期
关于神经网络的想法由来已久，远在1800年人们已经开始研究神经网络，
1943年心理学家Warren McCulloch与数理逻辑学Walter Pitts在总结前人关于神经工
作原理的基础上将神经元工作数理化，随后冯·诺依曼在领导计算机设计时试图
使用神经网络的形式而不是目前的指令形式
[13]
，限于当时科技水平限制最后并
没有采用神经网络的方案。随着二十世纪六十年代控制论兴起以及计算机的出
现，联接主义学者迫切地期待建立一个可用的神经网络数学模型，在这个环境中，
受Warren McCulloch与Walter Pitts两人工作的启发下，Frank Rosenblatt提出了第一
个神经元模型—-感知器
[14]
，这标志着神经网络进入第一次浪潮。
- 3 -
哈尔滨工业大学本科毕业设计（论文）
图 1-1 感知器模型
如图1-1 所示，在感知器中，含有d个输入和1个输出，其中非线性激活函数为
阶跃函数，即
y =
1 若θ
T
x − b ≥ 0
0 其他
(1-1)
式中b为偏置项，有时也称之为阈值。如果从神经科学的角度上解释，在感知
器中，向量x相当于神经元接收到的刺激，而θ
T
x相当于刺激的叠加。当总的刺
激量到达一定阈值b时，神经元被激活，即y = 1，否则神经元对刺激不作反应，
即y = 0。
伴随感知器一同被提出的还包括感知器训练算法，其方法借鉴了生理学中关
于反馈方面的思想，通过引入奖励与惩罚的概念，当某个训练样本被正确分类时，
参数维持不变，若该样本被错误分类，则通过惩罚项对对参数进行更新
[2]
。
得益于非线性的激活函数，感知器网络可以实现逻辑功能以及非线性分类任
务。例如，在输入维度为2的感知器网络中，若网络参数θ = [−2, −2]
T
，偏置b = 3，
此时，这组参数构成的感知器即为门电路中的与非门。由于与非门可以构成与、
或、非三种基本逻辑门，而这三者又可以构成所有的逻辑函数，因此我们有理由
相信，恰当的感知器网络可以实现逻辑功能。事实上，六十年代感知器网络的提
出，也确实解决了一些简单的人工智能任务。
神经网络第一次浪潮只持续了大约十年左右，究其原因，一方面，六十年代
是电子计算机刚刚兴起的年代，人们更多地关注于计算机，导致感知器网络得不
到重视，另一方面，限于电子管及早期晶体管的工艺，耗费大量的资源来建立一
个感知器网络似乎也不太现实。此外，人们一直没有找到一种能较好地训练多层
感知器网络的算法，导致了大批神经网络学者对其失去信心，因此，在六十年代
末期，神经网络的研究进入第一个低谷。
- 4 -
哈尔滨工业大学本科毕业设计（论文）
1.2.3 反向传播时期
神经网络研究在八十年代进入第二次浪潮，最重要的原因是1986年Hinton、
Remelhart和Williams等人提出了反向传播算法
[15]
，首次在手写数字识别任务上使
用反向传播训练的神经网络，取得了较好的效果。此外，大规模集成电路的发展
以及sigmoid等新的激活函数的应用也很大程度程度上推动了神经网络的发展。
反向传播算法通过链式求导，将偏导数从高层传送回低层，使得多层感知器
网络中可以使用简单的梯度下降方法进行训练，尤其是在三层感知器网络中效果
显著。随后，感知器网络也改名为神经网络，尽管如此，神经网络只是人为主观
地对神经元建模，其本质与生物的神经系统是没有太大联系的，例如神经具有局
部稀疏性而神经网络是非局部的，因此神经网络在生物学上被批评为缺乏真实
性。
在这个时期，新的模型不断地被提出，比如使用Hebb规则全连接的反馈网
络Hopfield网络
[16]
、将Hopfield网络随机化后的玻尔兹曼机
[17]
、具备模式变换不变
性的卷积网络等
[3]
，此外，一些新的技术例如快速传播、共轭梯度等也被应用到
神经网络中。
九十年代人们开始尝试建立深度神经网络，但随着网络深度的加大，局部最
优解增多，在参数没有被恰当地初始化的情况下，使用反向传播算法进行简单的
梯度下降容易陷入局部极小值，人们难以找到一种较好的方法来训练深度网络。
在硬件方面，九十年代计算机的计算能力仍不足以满足深度神经网络中大规模的
运算。此外，同时期被提出的SVM方法可以在较少运算的前提下实现高性能的分
类，因此，在九十年代中期，神经网络进入第二次低谷。
1.2.4 深度学习时期
深度神经网络的僵局一直持续到2006年，Hinton与Osindero在深度置信网络中
使用一种无监督的逐层贪婪预训练受限玻尔兹曼机，使得权值被初始化到一个合
适的位置，随后对整个网络使用全局的反向传播进行有监督的微调，在MNIST手
写数字识别任务上超越了已有的记录
[6]
，随后，在受限玻尔兹曼机的基础上又发
展出了稀疏编码与自动编码机等方法。深度置信网络是一种无监督学习，对应的，
由LeCun等人提出的深度卷积网络实现了在深度结构下的有监督学习
[18, 19]
，成为
第一个真正意义上的深度结构。
自2006年 以 来， 深 度 学 习 的 研 究 持 续 升 温
[20, 21]
， Google、 Facebook、
Microsoft等公司以及麻省 理 工、斯坦 福 大学、多伦多 大 学等高校 投 入大量 资
- 5 -
哈尔滨工业大学本科毕业设计（论文）
源到深度学习的相关研究中，麻省理工大学在2013年将深度学习评为十大突破技
术的榜首
[22]
。由于深度学习需要训练样本容量足够大，而近年来大数据时代的到
来，人们难以处理规模如此庞大的数据，所以某种程度上，深度学习与大数据是
相辅相成的。
2012年 前 后，国 内 各 大 公 司 逐 渐 投 入 到 深 度 学 习 相 关 的 研 究 中，百 度
于2013年开展百度大脑计划，成立“深度学习研究院”，这是百度首次成立研
究院，并于2014年邀请了深度学习的领军人物吴恩达作为首位院长。腾讯公司
于2014年开发的Mariana平台将致力于研究深度学习在语音识别、图像识别和广告
推荐上的应用。2015年京东将开展“JIMI”机器人项目，企图将深度学习应用到
人工客服上。
1.3 深度学习在人工智能上的应用
深度学习在人工智能领域正在取得重大进展，利用这套技术解决了历史遗留
的大量问题，目前已被应用到科学、商业、政策上。除了在传统的声、图、文领
域深度学习掀起巨浪外，深度学习逐步开始渗入到生物学等其他领域。
1.3.1 语音识别
传统的语音识别一般使用混合高斯模型（GMM）或隐马尔可夫模型（HMM）
[3]
，这 些 模 型 一 般 都 比 较 简 单，难 以 实 现 较 高 的 正 确 率。 Microsoft于2009年
与Hinton在语音识别方面展开合作，并于2011年实现了深度学习在语音识别上
的应用，该应用已经投入到WindowsPhone的语音识别“小娜”中。Google、百度
也开展语音识别框架的改革，Google使用4∼5层的神经网络，而百度使用9层的神
经网络
[22]
。使用深度神经网络实现的语音识别在错误率上要比传统方法的错误率
相对少20% ∼ 30%左右。
1.3.2 图像识别
在声、图、文三个领域中，深度学习在图像识别上对识别效果的提升最显
著。在MNIST手写数字识别任务中，使用传统识别方法的正确率一般为98%左
右，使用SVM能达到98.6%的正确率，而使用深度学习方法在最好的情况下能达
到99.79%的正确率。在ImageNet1000任务中，对于1000个类别的识别，随着深度
学习的研究进展，其识别效果分别经历了72%、85%、89%、93%等阶段，截止
- 6 -
哈尔滨工业大学本科毕业设计（论文）
到2015年1月，由微软亚太研究院实现的最好效果为96.06%
[23]
。在SVHN街景门牌
号的识别任务中，Google通过11层的神经网络对门牌号实现了97.84%的正确率，
这个系统已经帮助Google从街景中分析出全球近1 亿个门牌号。
1.3.3 自然语言处理
Microsoft于2012年在天津展示了使用深度学习训练的同声翻译系统，其英中
翻译较传统方法更为流畅。然而，目前在自然语言处理领域，深度学习取得的效
果并没有显著超越传统方法。相比于图像识别以及语音识别，自然语言处理一个
难点在于上下文，尽管深度学习被认为是一种特征学习，但这种特征学习似乎并
没有实现可以联系上下文的功能。自然语言处理在近期广受关注，深度学习研究
人员认为下一个突破口将会出现在自然语言处理上。
- 7 -
哈尔滨工业大学本科毕业设计（论文）
第 2 章 控制论与机器学习
控制论其本质，在于利用已有的信息抑制系统熵的增加
[24]
，需要注意的是，
这里的熵并不是指热力学中的热力熵或信息论中的信息熵，而应理解为熵的原始
定义，即对混乱的度量。既然是度量，便需要一个准则，正如测量一个物体的长
度需要一把刻度尺，但不同的刻度尺将得到不同的测量结果，同理，对混乱的不
同定义，也将得到不同的控制效果。例如，在温度控制系统中，让温度保持在一
个较高的温度或较低的温度均是抑制熵增的行为，因为两者对熵的定义不同。对
于孤立系统，熵总是朝着增加的方向移动，但也有例外，此时系统必须是非孤立
的，能够收到外界的控制，比如有机体具有熵减趋势，因为DNA是有序的（尽管
我们目前仍无法完全理解它），其中起到控制作用的外力是自然选择。控制论所要
做的，便是引入外力作用，即反馈，或者说控制环节，以之降低系统的混乱程度，
得到我们的期望输出。
2.1 白盒模型与经典控制论
经典控制论中，为了实现对一个系统的控制，我们往往需要先由系统的结构
开始分析，利用牛顿力学、电磁原理、热力学等物理原理对系统特性建立微分方
程，将其转换为复域的传递函数后，再利用根轨迹或频域分析设计控制环节。如
图2.1 所示的简单RLC网络中，假定我们以u
i
(t)作为输入，u
o
(t)作为输出，那么此
时我们所拥有的信息是整个系统的结构，所需要抑制的混乱就是控制u
0
(t)朝着我
们的期望输出迈进。
图 2-1 简单的RCL网络
由于这个系统的结构是已知的，整个系统对于我们而言相当一个白盒。为此，
我们可以很容易地根据基尔霍夫回路电压定律建立方程
u
L
(t) + u
R
(t) + u
o
(t) = u
i
(t) (2-1)
- 8 -
哈尔滨工业大学本科毕业设计（论文）
进一步利用电感特性、电容特性、欧姆定律，式(2-1)可以进一步推导为
LC
d
2
u
o
(t)
dt
2
+ RC
du
o
(t)
dt
+ u
o
(t) = u
i
(t) (2-2)
此时，输入输出的微分方程已建立，下一步便是经典控制论的内容，我们并不打
算继续展开细说。在这个例子中，我们可以看出，白盒模型对整个系统是了如指
掌的，是可以对其建模的。此时，“利用已有信息抑制系统的熵增”相当于，对系
统建立传递函数（利用已有信息），设计控制环节使我们能得到期望输出（抑制熵
增）。
2.2 灰盒模型与系统辨识
牛顿一生的工作对自然科学的贡献是无以衡量的，但牛顿生活的时代忽视了
一些重要的东西—统计的概念。在牛顿力学中，有一个前提，系统的状态是可测
量的，因此，牛顿力学基于一个已给定的精确初始状态之上对系统分析。然而，
物理的测量从来都不是精确的，我们对世界的观察也总是片面而不确定的，世界
对我们而言是未知的，我们无法完全确定事物的运作机理。例如图2.1 中的电阻R，
R=50Ω 并不是一个严谨的说法，我们不知道物体细分到最小粒子（如果存在的
话）后事物是否变得精确，但就目前人类所拥有的知识而言，阻值为50Ω的电阻
是不存在的。我们平常所说的50Ω电阻只是一个统计概念，即电阻在50 Ω左右的
统计结果。延伸到整个系统，图2.1 的网络也变得不确定，R、L、C均是不精确的
值，此时系统变为一个灰盒模型。所谓灰盒模型，即系统的一部分内容是未知的，
另一部分内容是已知的的，例如这里，尽管R、L、C的精确值是未知的，但我们
依然可以知道其数值的大致范围。
倘若我们再推广一步，R、L、C的大致范围我们也不知道，如何设计该系统
的控制环节便是系统辨识所要研究的内容。系统辨识领域中的一个重要的话题是
如何解析出一个含有未知参数的系统结构，如果我们可以获取系统的输入输出样
本，利用这些样本，配合上含有未知参数的系统结构方程，采取恰当的拟合方法，
如最小二乘以及极大似然等，最后可以获取未知参数的近似解，使得这个灰盒模
型的灰色褪去（但不会褪为白盒模型），进一步便可设计系统的控制环节。
2.3 黑盒模型与统计机器学习
白盒模型与灰盒模型的讨论均是基于一个前提：我们知道系统整体模型框架，
只是某些参数有可能是未知的。但这个前提在实际生活中往往是不成立的，很多
- 9 -
哈尔滨工业大学本科毕业设计（论文）
时候，我们非但不知道系统的参数，甚至连系统的模型也知之甚少，此时的系统
相当于一个黑盒，我们无法了解其内部结构。例如，判断一封100字的邮件是否
为垃圾邮件，假设这个行为可以用一个函数来描述，即这个决策背后存在一个真
理（或者说函数），通过它，我们输入100 个字符，函数的输出告诉我们这封邮件
是否为垃圾邮件，那么我们便可以通过这个函数来描述这个系统。可以肯定的值，
这个函数在邮件完全可分（即不存在一些可能是或可能不是垃圾邮件的情况）的
前提下是存在的，因为字符编码是有限的，只需穷举即可得到这个函数的决策
面。但这个方法并不现实，假使所有的汉字只有2000个，那么100字的中文邮件将
有2000
100
种可能，要穷举是不可能的。另一种做法是寻求语法结构，先对这100字
进行分词，再进行语义分析，这个过程也可以描述为一个函数映射过程：假设函
数 f (x)代表分词，g(x)代表语义分析，y代表系统输出，那么系统的模型可以表述
为y = g[ f (x)]。这种想法早在二十年前就被抛弃，因为自然语言含有强烈的上下文
气息。例如在“冬天能穿多少穿多少，夏天能穿多少穿多少”这个例子中，同一
句“能穿多少穿多少”在不同的上下文中含有不同的意义。尽管我个人认为这种
上下文背后也必然存在一个因果关系，但这种因果关系是在是太难寻找了，所以
这种方法也不是一个可行的方案。
统计机器学习的做法是，假定一个模型（这个模型与系统本质的模型关联并
不大），利用大量样本训练假设的模型，最后将训练完毕的模型作为本质模型的逼
近。与之前讨论的系统辨识相比，两者在训练阶段是类似的，均是利用样本进行
参数整定，不同点在于，系统辨识是训练带有强烈先验的模型（比如由具体物理
原理推导出的传递函数）的参数，而统计学习训练的是假设模型（比如高斯模型、
隐式马尔可夫模型、神经网络、支持向量机等）的参数。
回到垃圾邮件分类的例子中，统计机器学习的一种解决方案是利用朴素贝叶
斯分类，这种方法中，所假设的模型是朴素贝叶斯模型。我们首先建立一个含
有d个元素的垃圾邮件特征字典，比如{ 购买、大促销、店庆···}，此时，任何一
封邮件都可以用一个d维列向量表示。例如，某封邮件在字典中的元素只包含“购
买”，而其他的元素均不包含，那么这封邮件便可以表示为
x = [1, 0, 0, ··· , 0]
T
(2-3)
如果我们有大量垃圾邮件样本，我们不难统计出字典中各个元素在垃圾邮
件中的出现概率p(x
i
|y = 1)，其中，y代表样本的标签，若该样本是垃圾邮件，
则y = 1，反之y = 0，x
i
代表字典中的第i个元素，例如，我们的字典中，x
1
= “购
买”。建立样本的描述方式后，我们采用朴素贝叶斯公式，计算样本为垃圾邮件
- 10 -
哈尔滨工业大学本科毕业设计（论文）
时的概率分布
p(x|y = 1) = p(x
1
, x
2
, ·, x
d
|y = 1)
= p(x
1
|y = 1)p(x
2
|y = 1) ··· p(x
d
|y = 1)
(2-4)
显然，式(2-4)在数学上只有在x
i
均独立时才成立，而本质上，x
i
并不是独立的（因
为存在上下文），这里本应使用全概率公式，而我们之所以假设x
i
独立的原因是这
样做可以降低模型的复杂度。所以说，在统计学习中，假设模型与本质模型的关
联往往不大。
模型训练完毕后（即计算p(x
i
|y = 1)），对于一封新收到的邮件，我们只需使
用贝叶斯公式即可计算该邮件是垃圾邮件的概率
p(y = 1|x) =
p(x|y = 1)p(y = 1)
p(x)
=
d
i=1
p(x
i
|y = 1)
d
i=1
p(x
i
|y = 1) +
d
i=1
p(x
i
|y = 0)
(2-5)
统计学习更像是一种假设检验，本例子中的朴素贝叶斯，完全抛弃了语义分析，
这并不符合自然语言的原理。但实际中，尽管这个模型并不是本质模型，但逼近
效果足以让人接受，能工作得很好，因此被很多邮件厂商所采用。
图 2-2 机器学习系统框图
如果一定要对机器学习下一个定义，我认为Tom.Mitchell的描述比较恰当：
对于某类任务T和性能度量P，如果一个计算机程序在T上以P衡量的性能随着经
验E而自我完善，那么我们称这个计算机程序从经验E中学习
[25]
。如果将这段话转
化成系统框图，则如图2-2 所示。
2.4 本章小结
精确性只存在于数学中，现实世界充满了不确定性，难以寻找事物背后的机
理。统计学习绕过这套机理，根据设计者的意愿，假设一个模型，利用这个模型
逼近事物的机理，相当于把世界看成一个黑盒，并不打算去探索黑盒的内部结构，
而是仿造一个黑盒来模拟其工作原理。
- 11 -
哈尔滨工业大学本科毕业设计（论文）
第 3 章 受限玻尔兹曼机
统计学习并不在乎事物的本质是什么，我们更关心的是数据的分布是怎样的，
为了描述数据的分布，我们往往引入各种各样的模型刻画这种分布，比如，贝叶
斯决策论中我们引入多维高斯分布，支持向量机中我们引入最大间隔分离面等。
对于同一个任务，采用不同的模型得到的结果是不一样的，机器学习与模式识别
的一个不同点在于，机器学习更注重统计，模式识别更注重于模型。例如，对于
同一个任务，机器学习学者可能会假设出多个模型，再根据模型选择理论选取一
个最优的模型，而模式识别学者更倾向于先大致分析这个任务更适合使用哪个模
型，选取后仔细优化这个模型。尽管两者有一定的差异性，但很多方面两者是共
通的，比如神经网络。神经网络并不依赖于具体的任务，也就是说，语音识别可
以用神经网络处理，图像识别也可以用神经网络处理，之所以能这样做的一个原
因是，神经网络的内部对于我们而言是透明的，如果我们只看重结果，希望有一
个模型可以在给定一个输出的时候输出一个决策结果，不需要关心这个结果是怎
么得到的，那么神经网络是一个很好的选择。神经网络的种类众多，一个分支是
玻尔兹曼机，这种网络灵感源自统计物理中的玻尔兹曼分布与伊辛模型，随后，
在这种网络的基础上又发展出一套受限玻尔兹曼机，通过这些网络，都可以建立
数据的概率分布描述。
3.1 伊辛模型
伊辛模型（Ising model）是统计物理中描述物质相变的一种模型
[16]
，是一个
相互磁耦合的自旋阵列。比如在铁这种物质中，当温度降到某个程度，微观原子
的自旋会表现出一定的倾向性，从而在宏观上产生磁矩，而当温度升高到一定程
度时，其自旋就变得随机。
假 设 某 个 伊 辛 模 型 中 有N个 自 旋 的 原 子， 对 于 每 个 原 子， 其 状 态 只 能
取+1或−1，我们用向量s来表示所 有 原子的状 态，亦 即s代表这个 伊 辛 模型的
状态，那么我们定义该伊辛模型处于状态s下的能量函数为
[16]
E(s; W, H) = −
1
2
N
i, j =1
w
i j
s
i
s
j
+
j
Hs
j
(3-1)
式中，w
i j
代表原子i和原子 j之间的耦合，如果i和 j是相邻的，那么w
i j
= C，否
则w
i j
= 0，如果常数C > 0，那么这个模型是铁磁性的，否则是反铁磁性的。常
- 12 -
哈尔滨工业大学本科毕业设计（论文）
数H代表作用场，E(s; w, H)代表能量函数，对于一般化的能量函数，我们也称之
为Lyapunov函数。如果将这个能量函数推广到H和W不是常数的情况，即
[16]
E(s; W, H) = −
1
2
N
i, j =1
w
i j
s
i
s
j
+
j
h
j
s
j
(3-2)
此时我们将得到一个物理学家称之为“自旋玻璃”的模型，这也是神经网络中的
“Hopfield网络”。
3.2 玻尔兹曼机
在统计物理中，对于一个具有一定自由度的物理系统，其系统的状态是具
有随机性的而不是固定的（比如房间中的氧气分子分布），假设系统处于某个状
态i的概率为p
i
，那么当系统与外界达到热平衡时，其概率分布为
p
i
=
1
Z
T
e
−E
i
/T
(3-3)
式中，T 代表系统所处的温度，E
i
代表系统处在i状态下的能量，Z
T
是在T 温度下为
了使得概率满足柯尔莫果洛夫第二公理的归一化常数。这个分布也称之为正则分
布或吉布斯分布。
在机器学习中，我们往往自定义一个能量函数，然后通过正则分布建立模型，
通过这种基于能量的模型来对数据进行分析。所以正则分布可以看做是机器学习
与统计物理间的桥梁。
如果将式(3-2)中的作用场去掉，并改写成矩阵形式，则得到玻尔兹曼机中的
能量函数
E(s; W) = −
1
2
s
T
W s (3-4)
事实上，在机器学习中我们并不关心常数T ，则玻尔兹曼分布为
p
i
=
1
Z
e
−E
i
=
1
Z
exp
1
2
s
T
W s
(3-5)
对于一个数据对象，假设我们能观察到n维特征，但不仅仅代表这个数据只
含n维特征，因此我们往往引入隐含特征的概念，假设对于一个对象，我们能观察
到v个特征，那么我们用v个节点来表示这些特征，又假设我们自定义隐含的特征
为h个，那么我们用h个节点来代表这个特征。比如图3-1 代表了含有4个可见节点
和2个隐含节点的玻尔兹曼网络。
由图3-1 可见，在玻尔兹曼机中，可见节点与可见节点之间、隐含节点与隐含
节点之间是可以有连接的，因此这是一个反馈网络。层内节点有连接可以大大地
- 13 -
哈尔滨工业大学本科毕业设计（论文）
a) 未拓扑前的玻尔兹曼机 b) 拓扑后的玻尔兹曼机
图 3-1 玻尔兹曼机网络构型
增强网络的表达能力，但是也大大地增加了网络的训练难度，因此玻尔兹曼机并
没有非常成功地解决人工智能的任务。
3.3 受限玻尔兹曼机
在受限玻尔兹曼机（Restrict Boltzmann Machine，RBM）中，我们取消层间连
接，从而出发后经过若干次“移动”也无法回到原点，因此RBM也可以认为是一
个有向无环图。其网络结构图3-2 所示。
图 3-2 RBM 网络构型
为了方便往后的讨论，我们约定网络参数的数学符号如下
W
n
h
×n
v
=
w
1,1
w
1,2
··· w
1,n
v
w
2,1
w
2,2
··· w
2,n
v
.
.
.
.
.
.
.
.
.
.
.
.
w
n
h
,1
w
n
h
,2
··· w
n
h
,n
v
v =
v
1
v
2
.
.
.
v
n
v
h =
h
1
h
2
.
.
.
h
n
h
b
v
=
b
v
1
b
v
2
.
.
.
b
v
n
v
b
h
=
b
h
1
b
h
2
.
.
.
b
h
n
h
(3-6)
式中，W
n
h
×n
v
代表网络的权值参数，w
i j
代表第i个隐含节点到第 j个可见节点间的
连接权值，因此W
n
h
×n
v
的第i行代表了通向h
i
的所有连接的权值，第 j列代表了通
- 14 -
哈尔滨工业大学本科毕业设计（论文）
往v
j
的所有连接的权值。v代表可见节点的状态，h代表隐含节点的状态，b
v
代表隐
含层到可见层的偏置，b
h
代表可见层到隐含层的偏置。
在RBM中，我们定义其Lyapunov函数如下
[26]
：
E(v, h) = −
n
v
i=1
b
v
i
v
i
−
n
h
j=1
b
h
j
h
j
−
n
v
i=1
n
h
j=1
h
j
w
j,i
v
i
(3-7)
若将(3-7)写成矩阵形式，则为：
E(v, h) = −b
T
v
v − b
T
h
h − h
T
Wv (3-8)
由正则分布的定义(3-3)，我们可以得到v，h的联合分布为
p(v, h) =
1
Z
e
−E(v,h)
(3-9)
其中配分函数Z为
Z =
v,h
e
−E(v,h)
(3-10)
由于实际中我们往往只能观察到可见节点，因此对联合分布(3-9)边缘化得
p(v) =
h
1
Z
e
−E(v,h)
=
1
Z
h
e
−E(v,h)
(3-11)
这个p(v)总可以写成如下形式：
p(v) =
e
−F(v)
Z
(3-12)
式中，我们称F(v)为自由能函数
[4]
，由式(3-11)与(3-12)，我们不难推出F(v)为
F(v) = −ln
h
e
−E(v,h)
(3-13)
为了继续我们往下的讨论，我们不加证明地引入关于受限玻尔兹曼机的一个
定理：
定理 3.1 在RBM中，在给定可见元状态时，隐含元的激活条件独立；反之，在给
定隐含元状态时，可见元的激活条件独立。
此外，我们还需引入一些记号
h
−k
= (h
1
, h
2
, ··· , h
k−1
, h
k+1
, ··· , h
n
h
)
T
(3-14)
α(k) = b
h
k
+
n
v
i=1
w
k,i
v
i
(3-15)
β(v, h
−k
) =
n
v
i=1
b
v
i
v
i
+
n
h
j=1
jk
b
h
j
h
j
+
n
v
i=1
n
h
j=1
jk
h
j
w
j,i
v
i
(3-16)
- 15 -
哈尔滨工业大学本科毕业设计（论文）
即h
−k
代表除k外的所有隐含元状态，β(v, h
−k
)代表除h
k
外所有节点构成的能量函数。
因此，总的能量函数(3-7)可以写为
E(v, h) = −β(v, h
−k
) − h
k
α(k) (3-17)
下面我们来推导隐含层的激活函数，在给定可见节点状态时，对于节点h
k
，
其激活概率为
P(h
k
= 1|v) (3-18)
由定理3.1，式(3-18)等价于
P(h
k
= 1|h
−k
, v) =
P(h
k
= 1, h
−k
, v)
P(h
−k
, v)
=
P(h
k
= 1, h
−k
, v)
P(h
k
= 0, h
−k
, v) + P(h
k
= 1, h
−k
, v)
=
1
1 + exp
− E(h
k
= 0, h
−k
, v) + E(h
k
= 1, h
−k
, v)
=
1
1 + exp
β(v, h
−k
) + α(k) · 0
+
− β(v, h
−k
) − α(k) · 1
=
1
1 + e
−α(k)
= sigmoid
α(k)
(3-19)
因此，给定可见层状态时，隐含元k的激活概率为
P(h
k
= 1|v) = sigmoid(b
h
k
+
n
v
j=1
w
k, j
v
j
) (3-20)
同理可推导在给定隐含层状态时，可见元k的激活概率为
P(v
k
= 1|h) = sigmoid(b
v
k
+
n
k
i=1
w
i,k
h
i
) (3-21)
由定理3.1的独立性可知
P(h|v) =
n
k
j=1
P(h
j
|v) (3-22)
P(v|h) =
n
v
i=1
P(v
i
|h) (3-23)
在RBM中，我们的目标是训练参数W，b
v
，b
h
使得模型能成功地刻画出数据
分布。为了方便起见，我们记θ = (W, b
v
, b
h
)，注意，这并不是矩阵合并，而是将所
有的参数用θ来代替。
假定我们有一个训练集S
- 16 -
哈尔滨工业大学本科毕业设计（论文）
S = {v
(1)
, v
(2)
, ···v
(i)
, ··· , v
(n
s
)
} (3-24)
其中n
s
为训练样本数，v
(i)
为第i个样本且
v
(i)
= [v
(i)
1
, v
(i)
2
, ··· , v
(i)
n
v
]
T
(3-25)
由于样本是独立的，因此似然函数为
L(θ) =
n
s
i=1
P(v
(i)
) (3-26)
对应的对数似然为
ℓ(θ) = ln
n
s
i=1
P(v
(i)
) =
n
s
i=1
ln P(v
(i)
) (3-27)
对于整个训练集，我们要优化参数，使得似然最大化，假设我们使用梯度上
升方法，则针对某个样本ˆv ，参数的更新规则为
θ = θ + η
∂ ln L
ˆv
∂θ
(3-28)
其中
ln L
ˆv
= ln P (ˆv)
= ln
1
Z
h
e
−E(ˆv,h)
= ln
h
e
−E(ˆv,h)
− ln Z
(3-29)
从而
∂ ln L
ˆv
∂θ
=
∂
∂θ
ln
h
e
−E(ˆv,h)
−
∂
∂θ
ln Z
(3-30)
由式(3-10)、式(3-11)、式(3-12)，得
∂ ln L
ˆv
∂θ
= −
∂
∂θ
F(ˆv) +
1
Z
v
e
−F(v)
∂
∂θ
F(v)
= −
∂
∂θ
F(ˆv) +
v
p(v)
∂
∂θ
F(v)
(3-31)
通过自由能函数F(v)对参数θ求偏导，我们有
∂
∂θ
F(v) =
h
e
−E(v,h)
·
∂E(v,h)
∂θ
h
e
−E(v,h)
=
h
e
−E(v,h)
/Z
h
e
−E(v,h)
/Z
·
∂E(v, h)
∂θ
=
h
p(v, h)
p(v)
·
∂E(v, h)
∂θ
(3-32)
从而，式(3-31)等价于
- 17 -
哈尔滨工业大学本科毕业设计（论文）
∂ ln L
ˆv
∂θ
= −
h
p(ˆv, h)
p(ˆv)
·
∂E(ˆv, h)
∂θ
+
v
p(v)
h
p(v, h)
p(v)
·
∂E(v, h)
∂θ
= −
h
p(h|ˆv) ·
∂E(ˆv, h)
∂θ
+
v,h
p(v, h)
∂E(v, h)
∂θ
= −E
p(h|ˆv)
∂E(ˆv, h)
∂θ
+ E
p(v,h)
∂E(v, h)
∂θ
(3-33)
式中，E
p(h|ˆv)
为p(h|ˆv)分布下的期望，E
p(v,h)
为p(v, h)分布下的期望。
通过式(3-33)，我们就可以计算相对于某个样本ˆv的对数似然梯度。式(3-33)中
的第一项是容易计算的，因为我们已经推导出了p(h|v)的分布形式，即式(3-20)和
式(3-22)。由于我们简记θ = (W, b
v
, b
h
)，因此我们需要对W，b
v
，b
h
三个参数分别
推导梯度公式。
h
p(h|v)
∂E(v, h)
∂w
i j
= −
h
n
h
k=1
p(h
k
|v)h
i
v
j
= −
h
i
h
−i
p(h
i
|v)p(h
−i
|v)h
i
v
j
= −
h
i
p(h
i
|v)h
i
v
j
h
−i
p(h
−i
|v)
= −
h
i
p(h
i
|v)h
i
v
j
= −
h
i
p(h
i
|v)v
j
(3-34)
h
p(h|v)
∂E(v, h)
∂b
h
i
= −
h
n
h
k=1
p(h
k
|v)h
i
= −
h
i
h
−i
p(h
i
|v)p(h
−i
|v)h
i
= −
h
i
p(h
i
|v)h
i
h
−i
p(h
−i
|v)
= −
h
i
p(h
i
|v)h
i
= −
h
i
p(h
i
|v)
(3-35)
h
p(h|v)
∂E(v, h)
∂b
vi
= −
h
p(h|v)v
i
= − v
i
(3-36)
- 18 -
哈尔滨工业大学本科毕业设计（论文）
尽管我们可以很容易地通过式(3-34)、式(3-35)、式(3-36)计算式(3-33)中的
第 一 项， 但 是 第 二 项 却 无 法 计 算，因 为 第 二 项 涉 及 到 归 一 化 因 子Z， 这 将
是O(2
n
v
+n
h
)复杂度的项，因此我们需要使用马尔可夫链蒙特卡罗方法（MCMC）进
行处理。
3.4 本章小结
本章中，我们从伊辛模型出发，引入玻尔兹曼机，进一步推广到受限波尔兹
曼机。在受限玻尔兹曼机中，我们建立了对数据描述的概率分布即正则分布，随
后，我们推导出受限玻尔兹曼机中由可见节点激活隐含节点以及由隐含节点激活
可见节点所使用的公式，此时，如果整个网络的参数是确定的，那么，利用这个
网络可以刻画数据的特征。但由于未经训练的网络参数是未知的，我们需要使用
样本来求取参数的近似值，求取的方法我们使用极大似然，为了使用梯度下降方
法最大化似然函数，我们对似然函数求导，进而得到每一步迭代所使用的梯度。
但由于这个梯度有一项不容易求取，我们需要利用马尔可夫链蒙特卡罗方法来处
理，但本章没有详细讨论，因此，本章节并不是一个独立的章节，考虑到马尔可
夫链蒙特卡罗方法所蕴含的内容较多，所以我们将其独立成为一章。
- 19 -
哈尔滨工业大学本科毕业设计（论文）
第 4 章 马尔可夫链蒙特卡罗方法
蒙特卡罗方法被评为“20世纪十大算法”之一，自20世纪50年代该方法被提
出后的几十年里已被学术界与工业界广泛应用。这套方法最初源自于Stan Ulam对
纸牌游戏的思考，他试图计算52张卡牌的组合可能，在尝试穷举失败后，他意识
到需要一种随机方法去求取近似解而不是花费大量时间求取一个精确解。随后，
他找到冯·诺依曼，两人共同完善了蒙特卡罗方法的一些理论，比如重要性采样和
舍弃采样。由于蒙特卡罗方法是一整套解决方案，算法众多，其理论贡献不能仅
仅归功于这两人，还应包括提出MH算法的Metroplis和Hasting、将蒙特卡罗方法应
用到中子扩散问题的Fermi等
[27]
。20世纪80年代，蒙特卡罗方法被引入机器视觉与
人工智能领域，同时，在此之上加入马尔可夫链形成一套新的理论体系。这套理
论常用于贝叶斯推断的归一化、边缘化与期望问题，概率论的配分函数问题，最
优化问题以及机器学习中的模型选择问题。
4.1 蒙塔卡罗方法核心思想
蒙特卡罗方法的一个应用是计算一个分布下某个函数的期望，现在假设我们
要计算一个积分
I
f
=
+∞
−∞
(2x
2
+ x + 1)
1
√
2π
exp
−
1
2
x
2
dx (4-1)
为了简化，我们记
f (x) = 2x
2
+ x + 1 (4-2)
p(x) =
1
√
2π
exp
−
1
2
x
2
(4-3)
那么，式(4-1)可以简写为
I
f
=
+∞
−∞
f (x) · p(x)dx (4-4)
由于p(x)恰好是一个标准高斯分布，倘若我们能从p(x)中采样得到N个独立同
分布（i.i.d）样本{x
i
}
N
i=1
，则积分I
f
可以近似为
[27]
I
f
≈
ˆ
I
f
=
1
N
N
i=1
f (x
i
) (4-5)
此时，若N → ∞，根据大数定律，可知
- 20 -
哈尔滨工业大学本科毕业设计（论文）
I
f
= lim
N→∞
ˆ
I
f
= lim
N→∞
1
N
N
i=1
f (x
i
) (4-6)
倘若从数学期望的角度上来解释上面的问题，那么积分(4-1)可以理解为：我
们现在有一个函数 f (x ) = 2x
2
+ x + 1，其自变量x 符合标准高斯分布，即x ∼ N(0, 1)，
那么为了计算 f (x)在分布N(0, 1)下的数学期望，我们可以在分布N(0, 1)中采样
出N个独立的样本{x
i
}
N
i=1
，将这些样本代入 f (x)，得到N个函数值{f (x
i
)}
N
i=1
，对这些
函数值求和取平均后得到的结果即为期望I
f
的近似值
ˆ
I
f
。显然，其近似程度与N有
关，N越大，采样的样本越多，近似的程度也便越高。
但积分(4-1)未免过于特殊，首先，p(x)是一个标准高斯分布，这使得我们可
以利用一些很成熟的方法来从N(0, 1)中采样出N个样本，但如果p(x)不是一个高斯
分布，也不是一个均匀分布、伽马分布等一些我们常见的概率分布，它只是一个
普通得不能再普通的分布，此时又该如何解决？ 其次，积分(4-1)只是一维形式，
而实际生活中的概率分布往往是高维的，那么高维情况又该如何推广？ 接下来的
几个小节我们将致力于解决以上几个问题。
4.2 舍弃采样
我们先来解决之前提到的第一个问题，如果说p(x) 不是一个常见的概率分布
应该如何解决？ 例如
p(x) = 0.3
1
√
2π
exp
−
(x − 2)
2
2
+ 0.7
1
√
2π
exp
−
(x + 2)
2
2
(4-7)
当 f (x)依然设定为(4-2)时，概率密度曲线p(x )以及函数 f (x) · p(x)的图像如图4-1 所
示
图 4-1 实际分布p(x)与 f (x) · p(x)的函数图像
- 21 -
哈尔滨工业大学本科毕业设计（论文）
此时，由于p(x)并不是一个常见的概率分布，而我们所拥有的一些简单的采
样方案基本都是针对于某一类特定的分布而提出的，基于这个原因，这里要想
在p(x)中采样出N个样本并不是一件简单的工作。为此，我们引入舍弃采样来解决
在任意分布上采样的问题。
舍弃采样基于这样一个思想： 既然我们无法从一个随意的分布p(x)上采样，
但是可以在一个特殊的分布q(x)上采样，比如从高斯分布中采样，那么我们为何
不用q(x)来逼近p(x )呢？ 为此，我们引入一个分布q(x)，称之为提议分布，这个分
布需要满足以下条件
[27]
p(x) < Mq(x), M < ∞ (4-8)
式中，M是一个定常数，上述约束条件相当于，提议分布q(x)与实际分布p(x)的
比值p(x)/q(x)需要在变量x的空间X中存在下界M。从图像的角度看，提议分布扩
大M倍后，应该“覆盖”，或者说“包着”实际分布p(x)，例如，对于式(4-7)的分
布p(x)，当M = 2.3且提议分布q(x)为
q(x) =
1
3
√
2π
exp
−
(x + 1.3)
2
2 × 3
2
(4-9)
即q(x ) ∼ N(−1.3, 3)时，实际分布p(x)与提议分布q(x)的图像如图4.2 所示
图 4-2 实际分布p(x)与提议分布q(x)的函数图像
由于提议分布是一个常规的高斯分布，我们有一系列的成熟方法可以在其之
上采样出多个样本。假设我们采样得到一个样本后，我们有两种选择：要么接受
这个样本，并将这个样本看做是从p(x)上采样得到的，要么舍弃这个样本，认为
这个样本与p(x)采样的样本差距太大，不能看做是p(x)的采样样本。
然而，我们什么时候应该接受q(x)的样本作为p(x)的样本，什么时候又应该拒
绝呢？ 为了刻画这个事件，我们引入了接受概率的概念。假定我们现在已从q(x)中
采样得到一个样本x
(i)
，则其接受概率A我们定义为
[16]
- 22 -
哈尔滨工业大学本科毕业设计（论文）
A =
p(x
(i)
)
M · q (x
(i)
)
(4-10)
计算得到接受概率后，我们以A作为接受样本的概率，但在计算机中，没有一
种方法直接地描述“以概率A接受样本”这个行为，为了仿真这个行为，我们可
以在区间为[0, 1]的均匀分布U(0, 1)上随机生成一个数u，若u < A则接受样本，否
则拒绝。通过这样的方式，我们便可以模拟“以A为概率接受样本”。我们很容易
将一个样本推广到N个样本的情况，其具体描述如算法4-1所示。
Input: 真实分布p(x)；提议分布q(x)；采样量N
Output: N个采样样本{x
(i)
}
N
i=1
1 i = 1;
2 repeat
3 采样x
(i)
∼ q(x)，获取随机数u ∼ U(0, 1)，A =
p(x
(i)
)
M·q(x
(i)
)
；
4 if u < A then
5 接受样本x
(i)
作为p(x)的样本，i+ = 1；
6 end
7 else
8 舍弃样本x
(i)
，i保持不变；
9 end
10 until i = N;
算法 4-1 舍弃采样算法
对 于 接 受 概 率 其 定 义， 一 种 较 为 直 观 的 理 解 是： 接 受 概 率A(x
(i)
)刻 画
了p(x
(i)
)与Mq(x
(i)
)的相似程度。如图4.2中的A、B、C三点，假设我们可以分别
从两个分布中采样得到多个样本，对于q(x)而言，采样样本出现在A点附近的概
率最大，其次是B点附近，再次是C点附近。然而，对于p(x)而言，采样样本出现
在B点附近的概率要比出现在C点附近的概率要小，因此，把从q(x)中采样得到的
样本直接作为p(x)的采样样本是不合适的。但由于
p(x
B附近
)
M · q(x
B附近
)
<
p(x
C附近
)
M · q (x
C附近
)
(4-11)
B点较小的接受概率使得我们舍弃了q(x)采样样本中B点附近大量的样本，C点较
大的接受概率使得我们保留了q(x)采样样本中C点附近的大量样本，经过舍弃阶段
后，我们便可以从q(x)的采样样本中筛选出可以刻画p(x)性质的样本，因此，舍弃
操作可以看做是对样本的纠正。
- 23 -
哈尔滨工业大学本科毕业设计（论文）
在q(x)定义为式(4-9)，p(x)定义为式(4-7)且M = 2.3的情况下，图4-3 a)为q(x)及
采样样本的概率分布直方图，将这些样本经过舍弃后，其分布直方图如图4-3 b)所
示。不难看出，尽管样本是从提议分布q(x)中采样得到的，但舍弃采样方法可以
很好地逼近原始分布，因此我们可以用筛选后的样本间接地作为p(x)的采样样本
而不再需要从p(x)中直接采样。
a) q(x)与样本分布直方图 b) p(x)与筛选后的样本分布直方图
图 4-3 舍弃采样的逼近效果
事实上，式(4-7)依然过于特殊，其概率密度不过是两个一维高斯分布的线性
组合，如果我们将其扩展到二维情形，例如，当真实分布p(x)与提议分布q(x)分别
定义为
p(x) =0.2 ·
1
2π
exp
−
(x + 1)
2
+ (y + 1)
2
2
+
0.1 ·
1
2π
exp
−
(x − 3)
2
+ (y + 3)
2
2
+
0.7 ·
1
2π
exp
−
(x − 2)
2
+ y
2
2
(4-12)
q(x) =
1
2 × 2
2
· π
exp
−
(x − 1.5)
2
+ y
2
2 × 2
2
(4-13)
在M = 3时，真实分布与提议分布的图像如图4-4 所示
以上例子都过于简单，实际中我们遇到的一般都是高维的情形，概率密度也
更为复杂。这将会导致一个结果，提议分布q(x)为了“包裹”真实分布p(x)，M需
要取一个很大的值使得q(x)可以覆盖掉最凸出的维度。想象这样一种极端的情
形，在一个高维度的p(x)中，有一个维度是类似于脉冲的尖峰，此时M需要取很
大才足以覆盖它，但对于剩余的维度而言，M可能只需要一个较小的值便可以
覆盖掉它们，为了使约束p(x) < M · q(x)恒成立，M需要取最大的值，过大的M使
得接受概率A = p(x)/Mq(x)过小，大规模地舍弃样本将使采样速度变慢甚至无法
再可以接受的时间内完成采样。究其原因，其最根本的弊端在于q(x)必须满足约
- 24 -
哈尔滨工业大学本科毕业设计（论文）
a) 全视图 b) 剖视图
图 4-4 二维真实分布（彩色）与提议分布（灰色）
束p(x) < M · q(x)。为了解决这个问题，我们将引入重要性采样，这种方法可以使
我们不受约束地选取任意的q(x)。
4.3 重要性采样
回顾章节4.1中的讨论，我们为什么要使用舍弃采样？ 因为蒙特卡罗方法中积
分式(4-4)在p(x)不是常规的分布形式时难以采样，导致我们无法利用式(4-5)来计
算积分。而舍弃采样通过构建一个容易采样的分布q(x)，对其采样样本筛选后作
为p(x)的样本，式(4-5)从而得以进行下去。
式(4-5)之所以能成立，是因为我们利用了点质量函数来逼近概率密度，即
[27]
p
N
(x) =
1
N
N
i=1
δ
x
(i)
(x) (4-14)
式中，δ
x
(i)
(x)为x
(i)
处的脉冲函数。下面我们将简单证明式(4-14)的正确性
1
为了得到概率密度p(x)，我们可以在x附近以x为中心建立一个小区域A，其对
应的体积为V
A
，此时我们从p(x)中随机采样N个样本x
1
, x
2
, x
N
，那么这些样本中落
入区域A中的概率为
P(x ∈ A) ≈
1
N
N
i=1
1(x
i
) (4-15)
式中，1(x
i
)为示性函数，其定义为
1(x)
0, x ∈ A
1, x A
(4-16)
1
感谢刘家锋老师的指点
- 25 -
哈尔滨工业大学本科毕业设计（论文）
实际上，式(4-15)的作用类似于窗函数的作用，即根据离散样本估计点密度，
但同时，根据连续性我们也可以得到点x的概率密度，即
P(x ∈ A) =
A
p(x)dx (4-17)
当 区域A为 无 穷小 区 域 时，即V
A
→ 0，区 域A内 的 每 一点 概 率 密度 相 等，此
时p(x)是常数，因此有
P(x ∈ A) =
A
p(x)dx = p(x)
A
dx = p(x)V
A
(4-18)
联合式(4-15)与式(4-18)，有
p(x)V
A
≈
1
N
N
i=1
1(x
i
) (4-19)
则
p(x) ≈
1
V
A
1
N
N
i=1
1(x
i
) ≈
1
N
N
i=1
1(x
i
)
V
A
≈
1
N
N
i=1
δ(x
i
)
(4-20)
因此式(4-14)成立，证明完毕。
倘若我们不采用这种逼近方式，而采用另外一种，在介绍这种方式之前，我
们先引入所谓的重要性权值w(x)，即
w(x) =
p(x)
q(x)
(4-21)
式中，q(x)为任意一个分布。此时，新的逼近方式可以陈述为
[27]
ˆp
N
(x ) =
N
i=1
w(x
(i)
)δ
x
(i)
(x ) (4-22)
对比式(4-14)，我们可以理解为p
N
(x )中的1/N相当于重要性权值恒为1/N。引入重
要性权值后，积分式(4-4)可以改写为
I
f
=
+∞
−∞
f (x)w(x)q(x)dx (4-23)
对应的，式(4-5)改写为
ˆ
I
f
≈
N
i=1
f (x
(i)
)w(x
(i)
) (4-24)
如果从另一个角度思考，以上讨论相当于，我们现在有一个目标函数 f (x)及
概率分布p(x)，要计算 f (x)在分布p(x)下的期望，由于p(x)不是一个常见的分布形
式，导致难以利用式(4-5)计算积分，那么我们构建一个常见的分布形式q(x)，将
目标函数改写为
- 26 -
哈尔滨工业大学本科毕业设计（论文）
ˆ
f (x) =
f (x)p(x)
q(x)
= f (x)w(x) (4-25)
则积分式(4-4)变为
ˆ
I
f
=
+∞
−∞
ˆ
f (x)q(x)dx (4-26)
此时我们又可以使用类似于式(4-5)的方式来计算积分了。
对比与之前讨论的舍弃采样而言，重要性采样的优点在于q(x )不受约束，也
不存在舍弃行为，这使得算法效率相对与舍弃采样有所提高。但重要性采样也有
其内在缺点，即q(x)选取的好坏程度影响着积分的精度，若q(x)选取得不好，则需
要大量的样本来提高积分精度。刻画q(x)好坏的一种准则是最小化
ˆ
I
N
f (x)的方差，
即
var
q(x)
f (x)w(x)
= E
f
2
(x)w
2
(x)
− I
2
( f ) (4-27)
由于I
2
( f )于q(x)无关可以摄取，再利用Jensen不等式，有
E
f
2
(x )w
2
(x )
≥ E
2
|f (x )|w(x )
=
|f (x )|p(x)dx
2
(4-28)
因此提议分布可以选取为
q(x) =
|f (x) |p(x)
|f (x )|p(x)dx
(4-29)
由于分母只是一个归一化常数可以不管，我们现在要做的是在|f (x)|p(x)中采样，
这看起来似乎没有什么用，实际上也确实没有什么用，毕竟|f (x)|p(x)并不似一
个容易采样的函数。但它启示我们一点，如果p(x)的样本落在的重要域可以使
得|f (x)|p(x)取值较大，那么采样效率将会非常高，这也是重要性采样的命名来
源。
无论是舍弃采样还是重要性采样都是独立采样，即样本之间是独立的，从而
采样效率较低。为了提高采样效率，我们可以使用关联采样，即样本之间存在关
联，构建样本之间的关联性所要用到的便是著名的马尔可夫链。
4.4 马尔可夫链
正式引入马尔可夫链之前，我们打算先从一个随机游走的例子入手。想象一
个正方形区域内，在某一点放入N个粒子，这些例子随机地朝着各个方向游走。
对于每一个粒子而言，每一次游走的步长是相等的，只是角度随机选择。当粒子
移动到正方形的边界是，它将被反弹回正方形区域内。直觉上的想象，经过漫长
的时间，粒子将漫布在整个正方形区域内。如图4-5 所示是两个随机游走的例子，
- 27 -
哈尔滨工业大学本科毕业设计（论文）
其中蓝色的初始状态在中心附近，绿色的初始状态在左下角。
图 4-5 两个随机游走的例子
这个例子类似于布朗运动，有趣的现象是，起始位置的选取并不会影响最终
结果—粒子终将呈均匀分布。正如一锅未加盐的汤，无论盐从哪个位置撒下，最
终整锅汤的咸淡是均匀的。对于某个特定的粒子而言，追踪它的轨迹是无意义的，
从宏观上看，粒子下一步处于哪个位置与之前的位置无关，只与它当前的位置有
关，因为它是经过怎样的路径到达当前的状态对下一步移动到哪里起不到任何作
用。
马尔可夫链也是基于同一个原理，假设我们的变量x可取得状态有s个，那么
集合S = {x
1
, x
2
, x
s
}被称为状态空间，马尔可夫链刻画的是变量x在状态空间S 中各
个状态之间迁移的轨迹。类似于随机游走的例子，马尔可夫链的下一个状态与之
前的状态无关，只与当前的状态有关，即
p(x
(i+1)
|x
(i)
··· x
(1)
) = p(x
(i+1)
|x
(i)
) (4-30)
这个性质也被称为马尔可夫性质。对于给定的系统，我们定义某个状态转移到另
一个状态的概率为转移概率为
p(x
(i+1)
|x
(i)
) = T (x
(i)
→ x
(i+1)
) (4-31)
如图4-6 中的系统，状态空间为{A, B, C}，由图中的参数我们容易算得转移矩
阵T
T =
T (A → A) T (A → B) T (A → C)
T (B → A) T (B → B) T (B → C)
T (C → A) T (C → B) T (C → C)
=
0 0 1
0.6 0 0.4
0 0.2 0.8
(4-32)
- 28 -
哈尔滨工业大学本科毕业设计（论文）
图 4-6 马尔科夫链
倘若我们为A、B、C赋予一些实际意义，我们令A代表下雨，B代表多云，
C代表晴天，又假设今天的天气为下雨，现在我们要估计10天后的天气状况。首
先，我们可以很容易地将今天的天气描述为一个向量
x = [1 0 0] (4-33)
为了计算10天后的天气，用x 乘以10 次转移矩阵后将得到10天后的天气状况，即
[1 0 0] ×
0 0 1
0.6 0 0.4
0 0.2 0.8
10
= [0.091 0.151 0.758] (4-34)
也就是说，10天后下雨的概率为0.091，多云的概率为0.151，晴天的概率为0.758。
倘若我们假设今天的天气为多云，利用同样的方法，我们可以计算得10天后
的天气状况为
[0 1 0] ×
0 0 1
0.6 0 0.4
0 0.2 0.8
10
= [0.091 0.151 0.758] (4-35)
我们发现，不管今天是雨天开始多云，计算得到10天后的天气情况是十分接近的
（这里完全一样是因为我们舍去了尾部小数），如果读者有兴趣的话可以验证初始
状态为晴天是得到的结果也是一样的。也就是说，不管今天的天气如何，对10天
后的天气均无影响
2
。
之所以出现这种现象是因为马尔可夫链在第十个周期时已经进入一个我们称
之为平稳的状态。类似于之前的随机游走，当经过足够长的时间后，系统的状态
与初始状态再无关联，只与系统的结构（也就是转移矩阵）有关。但并不是所有
的转移矩阵都能达到平稳，在这里，我们并不打算深入讨论，只给出结论定理
2
需要解释一下，这个天气系统是我们假设的，实际中的天气系统并不会如此简单
- 29 -
哈尔滨工业大学本科毕业设计（论文）
定理 4.1 如果一个马尔科夫链是各态遍历的，那么存在一个时间t
s
，当t > t
s
时，
马尔可夫链到达一个平稳分布x
∗
，其中x
∗
满足
x
∗
= x
∗
T (4-36)
所谓各态遍历，即要求马尔可夫链是不可约且非周期的，所谓不可约，即所
有状态都是有关联的，从某个状态出发，不存在无法到达的状态，所谓非周期，
即马尔可夫链不会陷入某几个状态间循环，满足上述两个条件的马尔可夫链我们
称它是各态遍历的。
利用马尔可夫链的这个性质，我们就可以实现关联采样。由于初始状态与稳
态无关，我们可以随机设置，经过多次随机游走，进入稳态后得到的状态便可
以作为一个样本。以上讨论均基于一个前提，即转移矩阵是已知的。然而，实际
中，我们并不知道转移矩阵的数值。例如，我们并不知道由晴天转移到多云的概
率是0.2，这个数值是我们捏造的。但是一旦转移矩阵知道了，采样问题便迎刃而
解，目前成熟的马尔可夫链蒙特卡罗方法整体框架都是类似的，不同的地方往往
在于转移矩阵的构造上。
4.5 Metropolis-Hastings算法
与舍弃采样类似，Metropolis-Hastings算法（以下简称MH算法）也存在一个
提议分布，这个提议分布定义为q(x
∗
|x)，不同的是，舍弃采样中的提议分布受一
个强约束，即p(x) < Mq (x )，而MH算法中的提议分布只需要满足q(x
∗
|x ) > 0即可，
显然这个约束相当于没有约束，因为概率论三大公理的第一条就使这个约束成
立了。另一个不同点在于，MH算法中的提议分布其意义为：在当前状态x 下，由
提议分布q(x
∗
|x )产生一个试探性状态x
∗
，随后根据接受概率决定是否转移到新状
态x
∗
上，这里，接受概率定义为
A =
p(x
∗
) · q(x|x
∗
)
p(x) · q(x
∗
|x )
(4-37)
此时，若接受概率A > 1，则接受这个新状态，否则，以概率A接受新状态。若接
受了这个新状态x
∗
，则状态从x转移到x
∗
处，并在x
∗
处的提议分布q(x
∗∗
|x
∗
)产生一个
新的试探状态x
∗∗
，如此反复循环，若不接受这个状态x
∗
，则状态仍然停留x处。
需要注意的一点是，在MH采样中，提议分布q(x
∗
|x)是对着状态x的变动而变
动的，例如，如果我们将提议分布q(x
∗
|x )设计成一个在以x为中心，以2为方差的
高斯分布，即q(x ∗ |x) ∼ N(x, 2)，那么如图4-7所示，在x
(1)
状态和x
(2)
状态下的提议
分布是不同的。
- 30 -
哈尔滨工业大学本科毕业设计（论文）
图 4-7 不同状态下的提议分布
综合以上的讨论，MH算法可以描述为算法4-2 中的过程。
Input: 真实分布p(x)；提议分布q(x
∗
|x )；游走次数N
Output: 1个采样样本x
(N)
1 设置初始状态x
(0)
，i = 0;
2 repeat
3 采样x
∗
∼ q(x
∗
|x
(i)
)，获取随机数u ∼ U(0, 1)；
4 计算接受概率A =
p(x
∗
)·q(x|x
∗
)
p(x)q(x
∗
|x)
5 if u < A then
6 x
(i+1)
= x
∗
；
7 end
8 else
9 x
(i+1)
= x
(i)
10 end
11 until i = N;
12 返回x
(N)
算法 4-2 Metropolis-Hastings算法
相比于舍弃采样，舍弃采样的拒绝是直接抛弃样本，而MH采样的拒绝是让
样本停留在当前状态。另一个不同点在于，算法4-2描述的是采样出一个样本的过
程，是一个随机游走的过程，而算法4-1描述的是采样出N个样本的过程。尽管算
法4-2只能采样出一个样本，但是我们也可以很容易将其扩展成为残阳N个样本的
算法。另外，由于各个样本的随机游走是独立的，不存在线程安全问题，因此算
- 31 -
哈尔滨工业大学本科毕业设计（论文）
法4-2可以很容易设计成为并行算法。
正如我们提到的，如果我们使用一个形式为q(x
∗
|x ) ∼ N(x, 2)的提议分布区采
样1000个式(4-7)中实际分布p(x)的样本，对于不同的游走次数N，其结果如图4-8
所示
a) N = 10 b) N = 100
c) N = 1000 d) N = 100
图 4-8 不同游走次数下的样本分布直方图
从图中我们不难发现，在游走次数N = 10时，逼近效果并不完美，随着N的增
大，当N = 100时，采样结果已经能很好地刻画实际分布了。此时，N再增大（比
如1000或5000）已经差别不大。从随机游走的角度上看，可以理解为，N = 100时
就已经进入平稳分布，再继续游走下去并没有太大意义。
MH采 样 可 以 认 为 是 很 多MCMC方 法 的 模 板， 其 他 的MCMC方 法 大 多 都
是MH算法的特例。之所以会从MH算法中衍生出如此多的分支是因为MH有其
自身的局限性。首先，我们难以估计状态是否进入平稳状态，即游走次数N难以
确定。其次，MH算法在高维问题中的效果并不好，因为高维空间的地形复杂，
MH算法一不小心就会落入一个周围状态的接受概率都很小的区域，这将导致试
探状态不断地被否决，从而长时间留滞在该点附近。接受概率的存在，使得游走
- 32 -
哈尔滨工业大学本科毕业设计（论文）
效率低下，而Gibbs采样是MH采样的一个特例，这种方法不存在接受概率，或者
说接受概率为1，因此每一次游走都将得到一个新的状态，这个特性将大大地加快
收敛速度。
4.6 Gibbs采样
Gibbs采样又称为热浴方法或“Glaber动力学”
[16]
，常用于解决高维分布中的
采样问题。假设我们有一个d维向量x，并且知道任一分量的条件概率分布形式
p(x
j
|x
−j
) p(x
j
|x
1
, ··· , x
j−1
, x
j+1
, ··· x
d
) (4-38)
则我们构建提议分布
[27]
q(x
∗
|x ) =
p(x
∗
j
|x
−j
) 若x
∗
−j
= x
−j
0 其他
(4-39)
由于Gibbs采样是MH采样的特例，而MH采样的接受概率公式(4-37)又可以描
述为
A = min
1,
p(x
∗
) · q(x|x
∗
)
p(x) · q(x
∗
|x )
(4-40)
将式(4-39)代入式(4-40)，并利用x
∗
−j
= x
−j
性质以及贝叶斯公式，有
A = min
1,
p(x
∗
) · p(x
j
|x
∗
−j
)
p(x) · p(x
∗
j
|x
−j
)
= min
1,
p(x
∗
) · p(x
j
|x
−j
)
p(x) · p(x
∗
j
|x
∗
−j
)
= min
1,
p(x
∗
−j
)
p(x
−j
)
= 1
(4-41)
由式(4-41)我们不难得出结论，Gibbs的接受概率恒为1，亦即在Gibbs采样中，
我们不存在丢弃样本或状态停滞的行为，每一次都会转移到一个新的状态上，这
显然会加快算法的收敛速度。
以上内容未免过于晦涩，为了方便大家理解，我们将再次阐述Gibbs采样的
原理。首先，Gibbs采样要基于一个大前提—真实分布p(x)在各个维度的条件概
率分布是已知的，即p(x
j
|x
1
, ··· , x
j−1
, x
j+1
, ··· , x
d
)已知。如果这个条件概率分布是
未知的，则使用Gibbs采样不是一个恰当的策略，因为Gibbs采样的提议分布是基
于这个条件概率分布之上构建出来的。式(4-39)定义的提议分布，其含义为： 固
定x
1
, ··· , x
j−1
, x
j+1
, ··· , x
d
这d − 1个维度的状态不变，单独处理d个维度中的一个，
- 33 -
哈尔滨工业大学本科毕业设计（论文）
即x
j
。如果将Gibbs采样试想成为一只章鱼，那么每次它都只迈出一只脚，当这只
脚固定后，再迈出剩下的另一只脚，因此，Gibbs采样的算法描述如算法4-3所示。
Input: 各个维度的条件分布p(x
j
|x
−j
)；游走次数N
Output: 1个采样样本x
(N)
1 设置初始状态x
(0)
，i = 0;
2 repeat
3 采样出第1个维度x
(i+1)
1
∼ p(x
1
|x
(i)
2
, x
(i)
3
, ··· , x
(i)
d
)
4 采样出第2个维度x
(i+1)
2
∼ p(x
2
|x
(i+1)
1
, x
(i)
3
, ··· , x
(i)
d
)
5
.
.
.
6 采样出第 j个维度x
(i+1)
j
∼ p(x
j
|x
(i+1)
1
, ··· , x
(i+1)
j−1
, x
(i)
j+1
, x
(i)
d
)
7
.
.
.
8 采样出第d个维度x
(i+1)
d
∼ p(x
d
|x
(i+1)
1
, x
(i+1)
2
, ··· , x
(i+1)
d−1
)
9 until i = N;
10 返回x
(N)
算法 4-3 Gibbs采样算法
至 此，MCMC的 大 体 内 容 已 讨 论 完 毕，让 我 们 回 到 第三章 遗 留 的 问 题。
第三章中，式(3-33)，即
∂ ln L
ˆv
∂θ
= −E
p(h|ˆv)
∂E(ˆv, h)
∂θ
+ E
p(v,h)
∂E(v, h)
∂θ
(4-42)
我们说，式中的第一项期望是容易处理的，而第二项却难以处理，因为如果
我 们 采 用 穷 举 的 方 法 解 决 这 个 问 题，这 将 会 是 一 个O(2
n
v
+n
h
)复 杂 度 的 运 算，
但采用MCMC的方法就很好处理。由于目前我们需要解决的问题是
∂E(v,h)
∂θ
在分
布p(v, h)下的期望，根据式(3-7)中对能量函数E(v, h)的定义，偏导数非常容易求
取。如果我们能在p(v, h)中采样出多个样本，那么这个问题便迎刃而解。但采
样p(v, h)是一件困难的事，幸运的是，我们知道p(v, h)的条件概率p(v|h)以及p(h|v)，
即式(3-22)和式(3-23)，因此我们完全可以通过Gibbs采样，经过多次状态转移后采
样出一个样本，再以同样的方法采样出多个样本，利用这多个样本，加以式(4-5)，
便可以算出期望值，整个问题便解决了。
- 34 -
哈尔滨工业大学本科毕业设计（论文）
4.7 对比离差
尽管第三章遗留的问题可以通过Gibbs采样解决，但事实上，正如我们前面提
及到的，马尔可夫链进入平稳分布的时间难以确定。我们知道，马尔可夫链的初
始状态对平稳分布在性质上是没有影响的，但是不同的初始状态会影响进入平稳
分布的时间。就如同往汤里加盐，在不同的位置撒下并不会影响最后的咸淡，但
会影响盐在水中的扩散速度，Gibbs采样也同理，不同的初始值对收敛速度有影
响。如果初始值随机设置，则模型的训练速度十分缓慢。Hinton提出了一种名为
对比离差
[28]
（Contrastive Divergence，CD）的方法，其中心思想是： 既然数据出
现了，那么说明这个数据是接近于平稳分布的，因此我们令初始值为该数据样本，
进行吉布斯采样，所以，对比离差算法如算法4-4所示。
Input: 条件分布p(h|v)和p(v|h)；迭代次数k
Output: 1个采样样本v
(k)
1 设置初始状态x
(0)
= data，i = 0;
2 repeat
3 采样出h
(i)
∼ P(h|v
(i)
)
4 采样出v
(i+1)
∼ P(v|h
(i)
)
5 until i = k;
6 返回v
(k)
算法 4-4 CD-k算法
算法4-4也被称为CD-k算法，随着k的增大，采样得到的样本越接近于模型的
平稳分布，但在实验中，k = 1的时候已经能获得很不错的结果，因此我们往往
令k = 1。而得到最终的采样样本v
(k)
后，对数似然的梯度近似为
∂ ln P(v)
∂w
i, j
≈ P(h
i
= 1|v
(0)
)v
(0)
j
− P(h
i
= 1|v
(k)
)v
(k)
j
(4-43)
∂ ln P(v)
∂b
vi
≈ v
(0)
j
− v
(k)
j
(4-44)
∂ ln P(v)
∂b
i
≈ P(h
i
= 1|v
(0)
) − P(h
i
= 1|v
(k)
) (4-45)
CD-k算法可以认为是利用
CD
k
= −
h
P(h|v
(0)
)
∂E(v
(0)
, h)
∂θ
+
h
P(h|v
(k)
)
∂E(v
(k)
, h)
∂θ
(4-46)
- 35 -
哈尔滨工业大学本科毕业设计（论文）
来近似
[29]
∂P(v)
∂θ
= −
h
P(h|v
(0)
)
∂E(v
(0)
, h)
∂θ
+
v,h
P(v, h)
∂E(v, h)
∂θ
(4-47)
利用CD-k，可以很高效地求得参数的增量∆W、∆b
v
以及∆b
h
，从而训练受限玻尔
兹曼机来刻画数据的分布。
4.8 本章小结
本章从蒙特卡罗的核心思想说起，引入舍弃采样，由于舍弃采样的提议分布
受到一个约束，为此我们又引入重要性采样。无论是重要性采样或是舍弃采样，
都属于非关联采样，因此我们引入马尔可夫链，得到一个关联采样方法，即MH采
样。MH采样在高维空间中效果并不好，且存在接受概率使算法效率较低，为此
我们引入用于解决高维问题且不存在接受概率的Gibbs采样，通过Gibbs采样可以
第三章的期望问题，但Gibbs的收敛速度依赖于初始值的设定，为了选取一个较好
的初始值，也为了加快算法的收敛速度，我们引入了对比离差方法。通过对比离
差，可以高效的解决第三章中的期望问题。事实上，马尔可夫链蒙特卡罗方法其
潜力并不仅局限于此，这套方法在机器学习中还有更为广泛的应用，然而我们并
没有涉及。至此，受限玻尔兹曼机的内容讨论完毕，通过一个训练好的
RBM
，就
可以刻画数据的分布。但目前的讨论并没有进入到核心内容，我们仍没有讨论识
别，或者说分类问题。在第五章中，我们将介绍如何用多个RBM作为砖块垒出一
个深度置信网络，并用这个网络进行图像识别。
- 36 -
哈尔滨工业大学本科毕业设计（论文）
第 5 章 深度置信网络
深度置信网络是由Hinton于2006年提出的一种深度全连接神经网络，全连接
的深度神经网络的训练是及其困难的，然而在深度置信网络中，我们采用网络的
逐层训练，随后对网络参数的微调，这种策略使得我们可以容易地训练多层神经
网络。由于深度置信网络本质是一种传统神经网络的推广，在本章中，我们将从
传统神经网络说起，介绍其训练方法，逐步将其推广到深度置信网络。
5.1 神经网络组成及表达能力
一个神经网络往往由多层神经元组成，神经元作为网络的基本单元，在给定
恰当的激活函数和权值的前提下，只要这个网络足够庞大，足以容纳较多的神经
元，那么这个网络可以表达任何一个连续函数
[30]
，当然这只是一个理论上成立的
理想情况，实际工程中，我们没有办法利用神经网络来描述所有的函数，但是这
个定理能使我们对神经网络的表达能力充满信心。
5.1.1 神经元
一个神经元如图5-1 所示，它包含d个输入x = [x
1
, x
2
··· , x
d
]
T
以及对应的d个权
值w = [w
1
, w
2
··· , w
d
]
T
，还有一个偏置b。此外，它还应包括一个执行非线性映射
的激活函数 f ( · )
图 5-1 神经元
与d个输入x = [x
1
, x
2
··· , x
d
]
T
直接相连的是数据的输入，例如，一张28 × 28像
素的灰度图像作为网络输入，由于该图像可以展开成28 × 28 = 784的列向量，
因此这个例子中的神经元就应该有784个输入，即x = [x
1
, x
2
··· , x
784
]
T
。d个权
值w = [w
1
, w
2
··· , w
d
]
T
，刻画了d个输入x = [x
1
, x
2
··· , x
d
]
T
的重要性，w中的某个分
量w
i
越大，说明对应的分量x
i
对最后决策结果的影响越大。从生物学的角度上看，
- 37 -
哈尔滨工业大学本科毕业设计（论文）
x相当于给予生物各种刺激，w相当于该生物对各种刺激的敏感度。例如，我们利
用神经元设计一个医学诊断系统来判定一个人是否需要住院观察，对于该神经元，
假设输入为x = [心脏疼痛, 头疼, 腰疼]，如果有某个症状，则对应位置1，否则置0。
显然，若一个人心脏疼痛，我们更倾向于让他住院观察，因此我们为心脏疼痛对
应的权值设定一个较大的权值w
1
= 0.9，头疼次之，我们设定为w
2
= 0.5，当一个
人腰疼时，不太可能需要住院治疗，我们为其设定一个较小的偏置w
3
= 0.1。因
此，这个神经元的权值为
w = [0.9, 0.5, 0.1]
T
(5-1)
假设现在有一位患者来到医院，他既有头疼又有心脏疼痛的症状，那么这位
患者可以表示为向量
x = [1, 0, 1]
T
(5-2)
此时，病情积累的严重性为
w
T
x = 0.1 + 0.9 = 1 (5-3)
那么这位患者是否需要住院呢？ 为此，我们利用前面提及到的偏置b来刻画这件
事。假设b = 0.7，如果w
T
x > b，则说明这位患者患有严重的疾病，需要住院观
察，网络输出y = 1，否则这位患者不需要住院，网络输出y = 0。如果我们定义为
神经元的净激活为
net = w
T
x + b (5-4)
净激活可以理解为排除偏置干扰后神经元接收到的刺激总和。那么上述判别过程
相当于用一个阶跃函数对净激活作一个非线性映射，即
y = f (net) =
1 若w
T
x − b > 0
0 其他
(5-5)
其中，由 于b是一个 常数，因此w
T
x + b与w
T
x − b并 没有区 别。但实际 上，
b = 0.7时的神经元做出的决策，其结果只由心脏疼痛这个因素决定，因为如果一
个患者没有心脏疼痛，那么最大的净激活是在他即患有头疼又患有腰疼的情况下
取得，此时w
T
x = 0.6。而0.6 < 0.7，并不会让他住院。因此，上面的神经元，转
换成等价的逻辑命题便是：如果一个人的症状中含有心脏疼痛，则需要住院，否
则不需要住院。如果我们把偏置调低，另b = 0.55，则此时等价的逻辑命题为：如
果一个人的症状中含有心脏疼痛，或者症状中既含有头痛有含有腰疼，则需要住
院，否则不需要住院。综合以上讨论，偏置起到的是阈值的作用，但是这个阈值
取多少就是设计者的意愿了，不同的阈值一般情况下会等价于不同的逻辑命题，
- 38 -
哈尔滨工业大学本科毕业设计（论文）
这取决于系统的期望输出是什么。
神经元总能转换成一个对应的逻辑表达，需要提出的一个因果关系是，我们
并不是从逻辑表达中推出神经元的参数，而是从神经元的参数中可以得到一个逻
辑表达。神经元的优点在于，通过一个神经元，便可以实现一个简单的决策，如
果拥有更多的神经元，将他们组合起来形成一个神经网络，便可以实现更为复杂
的决策行为。这个决策的因果关系是由参数决定的，后面我们将会看到，参数是
通过统计学习学到的，因此在神经网络中，我们不需要对事物的因果关系进行分
析，只需要使用大量的数据让网络学习其中的因果关系，这些因果关系对于我们
而言是透明的。
5.1.2 逻辑表达
在本小节，我们将再一次讨论网络的逻辑表达能力，如图5-2 所示的一个接收
两维输入的神经元，其偏置w = [−2, −2]
T
，偏置b = 3
图 5-2 与非门的神经元表达
如果我们的输入至少有一个为假，即x = [0, 0]
T
或x = [1, 0]
T
或x = [0, 1]
T
，则
网络的输出为真，即y = 1，若两个输入都为真，即x = [1, 1]
T
，则网络的输出为
假，即y = 0。事实上，图5-2等价于逻辑电路中的与非门，即
y = x
1
· x
2
(5-6)
由于与非门是通用门，利用多个与非门可以构建出三大逻辑门：与门、或门、非
门。因此，利用图5-2中的神经元可以表达任意一个逻辑函数。例如，在半加器
中，其逻辑函数为
y
1
= x
1
⊕ x
2
(5-7)
y
2
= x
1
· x
2
(5-8)
利用与非门搭建的电路图如图5-3 a)所示，而将其转换成对应的神经网络如图5-3
- 39 -
哈尔滨工业大学本科毕业设计（论文）
b)所示
1
。
a) 由与非门搭建的半加器 b) 由神经元搭建的半加器
图 5-3 半加器的两种不同描述
我们之所以花费篇幅去介绍神经元的表达能力，是为了说明神经网络确实能
实现一些逻辑决策，但并不意味着网络的权值需要我们手工设定的。这里的权值
之所以要手工设定，是因为我们精心筛选出来用以阐述神经网络的表达能力，但
实际应用中，权值是通过误差传播自动学习的，学习到的权值，其对应的逻辑命
题对于人类而言是难以理解的，但这并不重要，因为我们需要的是仅仅决策结果，
而不是这个决策是如何产生的因果关系。
5.2 神经网络的前馈
一般而言，神经网络是一个多层结构组织，网络的每一层都由多个神经元组
成，后一层的神经元由前一层的神经元激活。同一层的神经元之间没有连接，因
此同一层节点的激活是独立的。神经网络接收到一个数据后，逐层地激活各层的
神经元，前一层的输出作为后一层的输入，最后得到一个输出结果。这个过程称
为神经网络的前馈或前向传播。
图 5-4 神经网络的前馈
1
图中，为了美观，我们并没有将偏置画出来
- 40 -
哈尔滨工业大学本科毕业设计（论文）
如图5-4所示是一个三层神经网络，由于神经激活是自底向上传播的，如果各
层的激活函数都相同，为 f ( · )，则网络的第k个节点的输出为
z
k
= f
n
y
j=1
w
k j
f (
n
x
i=1
w
ji
) + b
j
) + b
k
(5-9)
式中，w
k j
为y层的第 j个节点到z层的第k个节点之间的连接权值，w
ji
为x层的第i个
节点到y层的第 j个节点之间的连接权值，b
j
为y层第 j个节点的偏置，b
k
为z层第k的
节点的偏置。
神经网络的这种自底向上的激活，有时也被解释为特征提取或重新编码。当
接收到一个数据时，神经网络将这个数据逐层地进行特征抽取，过滤掉一些冗余
信息，将剩余的重新编码，最后利用一个分类器将抽取到的最抽象（即最顶层）
特征进行分类，从而完成整个识别过程。
5.2.1 神经激活
到目前为止，我们只介绍了一种激活函数，即阶跃函数，但实际中我们并不
会使用阶跃函数作为激活函数。首先，阶跃函数是不连续的，其次，阶跃函数是
不可导的
2
。激活函数不可导，将导致网络无法利用反向传播进行训练，关于这点
我们将在反向传播章节讨论。作为激活函数，它应该满足以下几个条件
1. 它必须是非线性的。由式(5-9)可以看出，若激活函数是线性的，则多层神
经网络实际上只相当于两层网络，因为多个矩阵相乘的结果仍为一个矩阵。
网络一旦失去多层结构，则表达能力迅速下降。
2. 它应该具有饱和特性，即至少存在一个上界或下界。饱和特性的存在，使
得神经元的输出不至于过高或过低，整个网络的编码维持在一定的范围内。
但最近的研究表明，一些近似饱和的激活函数也能工作得很好，如此看来，
饱和似乎并不是必要的。
3. 它应该连续且可导。由于反向传播中需要求取激活函数相对于净激活的偏
导数，如果激活函数是不可导的，那么反向传播算法将无法执行。
实 际 工 程 中， 我 们 常 用 的 激 活 函 数 是sigmoid函 数
3
或 双 曲 正 切 函 数。其 中，
sigmoid函数我们定义为
f (net) =
1
1 + e
−net
(5-10)
其对应的图像如图5-5所示
2
事实上阶跃函数是可导的，其导函数为脉冲函数，这是一个广义函数，我们不深入讨论
3
也被称为logistic函数
- 41 -
哈尔滨工业大学本科毕业设计（论文）
图 5-5 sigmoid激活
可以看到，sigmoid函数是一个值域为(0, 1)的连续可导函数，其导函数有一个
重要特性，即
f
′
(net) =
e
−net
(1 + e
−net
)
2
=
1
1 + e
−net
−
1
(1 + e
−net
)
2
= f (net)
1 − f (net)
(5-11)
这个特性之所以重要，是应为利用式(5-11)可以直接通过网络的输出直接计算
激活函数相对于净激活的偏导数而不必引入额外的计算。我们看到，sigmoid函数
的输出范围为(0, 1)，有时候，我们希望网络的输出为(−1, 1)，此时可以使用双曲
正切函数，即
f (net) = tanh(net) =
e
net
− e
−net
e
net
+ e
−net
(5-12)
其对应的图像如图5-6所示
图 5-6 tanh激活
近年来，在神经网络的研究上又提出了一些新的激活函数，其中最重要的莫
- 42 -
哈尔滨工业大学本科毕业设计（论文）
过ReLU激活函数，其定义为
[31]
f (net) =
net 若net > 0
0 其他
(5-13)
式(5-13)也可以简写为
f (net) = max(0, net) (5-14)
其对应的图像如图5-7所示
图 5-7 ReLU激活
这种激活函数相比于sigmoid函数有较大的改进，关于其优点我们将留到反向
传播的章节讨论。但ReLU有一个缺点：在net < 0时导数为0，从而导致反向传播
无法更新参数。因此，在ReLU的基础上又产生了一些变体，例如，softplus中，激
活函数定义为
[31]
f (net) = log(1 + e
net
) (5-15)
其对应的图像如图5-8所示
图 5-8 softplus激活
- 43 -
哈尔滨工业大学本科毕业设计（论文）
从图中不难看出，softplus是ReLU的圆滑版，关于softplus，一个有意思的结
论是，其激活函数的导数为logistics函数，即
f
′
(net) =
e
net
1 + e
net
=
1
1 + e
−net
(5-16)
然而这个结论并没有什么用处，因为它并不能减轻程序的计算量。
ReLU的另一种变体是由He Kaiming等人提出的PReLU，其激活函数定义为
[23]
f (net) =
net 若net > 0
αnet 若net ≤ 0
(5-17)
式中，α为一个较小的参数，例如当α = 0.1时，其图像如图5-9所示
图 5-9 PReLU激活
显然，PReLU在负半平面不再会出现导数为0的情况。尽管参数α需要学习得
到，但这种方法在ImageNet 2012数据集上获得了非常好的识别效果，首次在图像
识别任务上超越了人的识别效果，错误率仅为4.94%。在该文中，作者提到了一个
有意思的现象：在较低层的网络中，学习到的参数α较大，而在高层的网络中，参
数α较小。作者的猜测是较低层网络需要尽可能多地保留数据的信息，因此激活函
数更倾向于类线性，而高层网络更倾向于抽象数据的结构，从而做出决策，因此
高层的激活函数更倾向于非线性。
在同一个任务中，激活函数的不同选取会有不同的实验现象，目前并没有证
明哪种激活函数更好。习惯上，在全连接神经网络中，我们更喜欢sigmoid派的激
活函数，而在卷积网络中，我们更喜欢ReLU派的激活函数，尽管这些都不是强制
的。
- 44 -
哈尔滨工业大学本科毕业设计（论文）
5.3 分类器
神经网络的逐层激活，其本质在于将一种编码转化成另一种编码。编码之间
的转换，可以过滤掉一些原始编码中无用的噪声或信息，这个过程一般都伴随着
熵的减小（但并不绝对）。然而，一个神经网络在最顶层的激活，其编码是人类所
无法理解的，因此，在最顶层节点之上还需要一个分类器对神经网络提取到的特
征或者说编码进行分类。分类器其作用，一方面在于将编码转换为人类所能理解
的编码，这在有监督的分类任务以及无监督的聚类任务中是必要的，因为我们最
后希望网络能给我们一个输出标签。但对于降维任务而言有时候并不是必要的，
因为降维并不需要输出标签。另一方面，分类器都带有一个准则函数，这个准则
函数定义了熵，即定义了什么是混乱，什么是有序。从控制论的角度上看，控制
工程中，误差是系统校正的核心，没有误差便没有反馈，没有反馈，则系统难以
控制。机器学习也是同样的道理，没有误差，则无法对参数进行校正，机器便无
法从样本中学习。误差的来源，源自于准则的定义，即预先预定什么是对的，什
么是错的，对与错之间就会存在一个误差，如果机器产生了一个误差，利用这
个误差便可以对参数进行校正。神经网络中，常用的分类器有三种：平方误差、
softmax、支撑向量机，尽管支撑向量机是一种重要的分类器，但是鉴于篇幅有限，
我们并不打算在本文中介绍支撑向量机，关于其原理读者可参考文献[32, 33]。
5.3.1 平方误差分类器
严格来说，平方误差并不能算作一个分类器，它充其量只能算作一个准则，
这个准则除了在神经网络中有应用之外，在很多领域也有广泛的应用。平方误差，
或者说二范数，其准则函数定义为
J =
d
i=1
(x
i
− t
i
)
2
(5-18)
式中，x
i
为网络的输出，这个输出由输入数据与网络参数共同决定，t
i
代表标签
值，也成为教师信号，由数据的标签值决定，d则是x的维数。假设一个神经网
络的最顶层有4个节点，网络的输出为[ −0.1 0.1 0.8 0.1 ]，而我们的期望输出
是[ 0 0 1 0 ]（再一次强调，这个期望输出由标签值决定），那么实际输出与期
望输出之间就会存在一个误差向量[ −0.1 0.1 0.2 0.1 ]，将其转化成平方误差后
为[ 0. 01 0.01 0.04 0.01 ]，利用式(5-18)可以很容易算的此时J = 0.07。事实上，
J = 0.07对我们而言没有太大用处，它最多只能刻画总的误差量有多大，真正对我
- 45 -
哈尔滨工业大学本科毕业设计（论文）
们有用的是平方误差向量，利用这个向量，可以将误差反向传播回神经网络的底
层，从而自顶向下就网络参数进行校正，关于这个过程更多的细节，我们将会留
到反向传播章节介绍。
5.3.2 softmax分类器
实际中，为了方便分类，我们往往希望网络的输出是“k中取1”的形式，例
如，假设我们有四个类别，如果使用二进制编码的话，我们只需两个节点即可，
即00代表第一类，01代表第二类，以此类推。如果我们使用所谓的“k中取1”形
式，我们便需要四个节点，即0001代表第一类，0010代表第二类，0100代表第三
类，1000代表第四类。为了实现“k中取1”的形式，我们需要引入softmax分类器，
softmax分类器可以认为是logistics回归的推广，在使用logistics回归进行分类时，
只能实现两类分类，而softmax分类器可以实现多类分类功能。
在softmax分类器中，假设容量为n的训练集为S =
(x
(1)
, y
(1)
), ··· , (x
(n)
, y
(n)
)
，
由 于 标 签y的 取 值 可 以 有c种， 因 此y
(i)
∈ {1, 2, ··· , c}。 我 们 引 入 记
号(ϕ
1
, ϕ
2
, ··· , ϕ
c
)来表示各个类别的输出概率，由于
ϕ
i
= 1，因此记号存在冗
余，只需要c − 1个记号(ϕ
1
, ϕ
2
, ··· , ϕ
c−1
)即可，对于ϕ
i
，有
ϕ
i
= P(y = 1; ϕ) (5-19)
以及
ϕ
c
= P(y = c; ϕ) = 1 −
c−1
i=1
ϕ
i
(5-20)
注意，正如我们之前提到的，ϕ中参数存在冗余，所以ϕ
c
并不是参数，而是一个为
了方便后面讨论所引入的一个记号。
由于softmax的概率分布也属于指数分布族，而在指数分布族中，对于概率分
布而言，都可以写成如下形式
P(y; η) = b(y) exp
η
T
T (y) − a(η)
(5-21)
在softmax中，我们记T (y) ∈ R
c−1
为
T (1) =
1
0
.
.
.
0
T (2) =
0
1
.
.
.
0
··· T (c − 1) =
0
0
.
.
.
1
T (c) =
0
0
.
.
.
0
(5-22)
- 46 -
哈尔滨工业大学本科毕业设计（论文）
记
T (y)
i
为T (y)的第i个元素，记1{·}为示性函数，即
1{A} =
1 ，若命题A为真
0 ，若命题A为假
(5-23)
因为
T (y)
i
= 1{y = i}，因此
E
T (y)
i
=
T (y)
i
· P(y = i)
= P(y = i)
= ϕ
i
(5-24)
而
P(y; ϕ) = ϕ
1{y=1}
1
ϕ
1{y=2}
2
···ϕ
1{y=c}
c
= ϕ
1{y=1}
1
ϕ
1{y=2}
2
···ϕ
1−
c−1
i=1
1{y=i}
c
= ϕ
T (y)
1
1
ϕ
T (y)
2
2
···ϕ
1−
c−1
i=1
T (y)
i
c
= exp
ln
ϕ
T (y)
1
1
ϕ
T (y)
2
2
···ϕ
1−
c−1
i=1
T (y)
i
c
= exp
T (y)
1
ln ϕ
1
+
T (y)
2
ln ϕ
2
+ ··· +
1 −
c−1
i=1
T (y)
i
ln ϕ
c
= exp
T (y)
1
ln
ϕ
1
ϕ
c
+
T (y)
2
ln
ϕ
2
ϕ
c
+ ··· + ln ϕ
c
(5-25)
对比式(5-21)，得
b(y) = 1 (5-26)
η =
ln
ϕ
1
ϕ
c
ln
ϕ
2
ϕ
c
··· ln
ϕ
c−1
ϕ
c
T
(5-27)
a(η) = −ln ϕ
c
(5-28)
定义
η
i
= ln
ϕ
i
ϕ
c
η
c
= ln
ϕ
c
ϕ
c
= 0 (5-29)
由于
e
η
i
=
ϕ
i
ϕ
c
(5-30)
则
- 47 -
哈尔滨工业大学本科毕业设计（论文）
ϕ
c
· e
η
i
= ϕ
i
(5-31)
且
ϕ
c
c
i=1
e
η
i
=
c
i=1
ϕ
c
e
η
i
=
k
i=1
ϕ
i
= 1 (5-32)
从而
ϕ
i
= ϕ
c
e
η
i
=
exp(η
i
)
c
i=1
exp(η
i
)
(5-33)
即
P(y = i; ϕ) = ϕ
i
=
exp(η
i
)
c
i=1
exp(η
i
)
(5-34)
以及
P(y = i|x; θ) =
exp(θ
T
i
x)
c
j=1
exp(θ
T
j
x)
(5-35)
本质上，softmax分类器都可以看做是一种两层神经网络，与常规的神经网
络中使用sigmoid函数作为激活函数不同，在softmax分类器中，激活函数 f (net
k
) ∝
e
net
k
，对应的激活概率定义为
[3]
z
k
=
e
net
k
c
i=1
e
net
i
(5-36)
式中，z
k
代表第k个节点激活的概率，net
k
代表第k的节点的净激活，取值为输入特
征x的线性函数，即net
k
= θ
k
x
T
，c为类别的总数。在式(5-36)中分母的作用下，我
们对每个类别的输出都进行了归一化，所以总的激活概率为1 。在识别中，计算各
个类别的激活概率后，只需选取最大激活概率所对应的类别作为输出类别即可。
5.4 神经网络的反馈
神经网络的反馈是基于准则函数的反馈，准则函数作为误差的度量，刻画了
网络的输出与训练集的标签两者之间的差异。整个反馈过程中，实质上就是准则
函数最优化的过程，即对网络的参数进行更新，使得误差不断减小。假设一个以
参数θ为自变量的误差函数 f (θ)，反馈过程就相当于不断寻求θ使得 f (θ)最小的过
程。如果 f (θ)是凸的，即Hessian矩阵是正定的，那么我们称这个问题为凸优化问
题，我们可以有很多策略解决凸优化问题，但实际中遇到的问题基本都是非凸问
题，解决非凸问题，一个简单有效的方法是利用梯度下降。想象我们在一座山上，
为了更快速的下山，我们可以每一步都朝着当前最陡峭的方向（即梯度方向）前
进，梯度下降也是基于这个原理，每一次迭代，我们都在当前的θ下计算 f (θ)的梯
度∆
θ
f (θ)，让θ加上这个梯度分量，也就是让它朝着梯度下降的方向迭代。由于梯
- 48 -
哈尔滨工业大学本科毕业设计（论文）
度下降的每一步都是基于当前的参数θ，所以这是一个贪婪算法，并不能保证收敛
到全局最优。如果 f (θ)是凸的，那么梯度下降在大部分情况下它会收敛到全局最
优（但并不绝对，受学习率影响），然而，实际任务由于其非凸性，我们基本上
不可能收敛到全局最小值，我们得到的往往是局部极小值。另外，值得一提的是，
收敛到全局最小值是没有意义的，因为这个全局最小值是基于训练集的最小值，
一旦收敛到此处，意味着网络可以很好地刻画训练集，但并不意味它同样可以很
好地泛化到测试集上，这个时候往往会伴随着较高的过拟合风险，我们不应一味
地最求全局最小，而应在训练集与测试集两者之间进行一个权衡。梯度下降，因
其简单有效的特点，称为优化问题中一个很常用的策略。
5.4.1 分类器参数校正
20世纪80年代以前，人们并没有找到一个较好的方法训练神经网络，这种状
况一直维持到1986年，在这一年里由Rumelhart与Mecelland为首的科学家小组
4
提
出了方向传播算法，首次在神经网络中利用梯度下降逐层地训练网络参数，每训
练完一层后将当前层的误差传递回前一层，依次迭代，最后完成整个网络的训练。
在这套方法中，核心点有两个：如何利用最顶层（即分类器）的误差来更新最顶
层的参数以及如何在某一层网络更新完参数后将该层的误差传播回前一层，我们
将会在本小节中讨论最顶层的参数校正，并在下一小节讨论误差传播。
5.4.1.1 平方误差分类器参数校正
由于在平方误差分类器中，准则函数定义为
J(θ) =
1
2
c
i=1
(t
i
− z
i
)
2
=
1
2
||t − z||
2
(5-37)
式中，z
i
为训练集的标签值，而网络的输出t
i
又是由前一层的静激活经过非线性映
射后得到的，即
t
i
= f (net
i
) (5-38)
式中，net
i
为输出层的前一层，即倒数第二层的净激活，而这个净激活又被定义为
net
i
= wx + b (5-39)
式中，w为输出层与倒数第二层两者之间的权值，b为偏置，因此，我们不难通过
链式求导得到误差相对于参数的梯度，即J(θ)相对于θ（这里的θ即为w和b）的导
数
4
事实上反向传播是由很多人在同一年代同时独立提出的
- 49 -
哈尔滨工业大学本科毕业设计（论文）
∂J(θ)
∂w
=
∂J(θ)
∂net
∂net
∂w
(5-40)
以及
∂J(θ)
∂b
=
∂J(θ)
∂net
∂net
∂b
(5-41)
如果此时的激活函数是sigmoid函数，那么容易知道
∂J(θ)
∂net
= net(1 − net) (5-42)
如果激活函数是ReLU函数，也容易得到
∂J(θ)
∂net
=
1 若net > 0
0 若net ≤ 0
(5-43)
而∂net/∂θ只是一个线性函数，同样容易求得
∂net
∂w
= x
∂net
∂b
= 1 (5-44)
利用(5-42)或(5-43)
5
以及(5-44)便可以求取式(5-40)以及(5-41)中参数应该修改的幅
度，即梯度。
5.4.1.2 softmax分类器参数校正
softmax的训练中，由于网络的输出为
z = E
T (y)|x; θ
= E
1{y = 1}
1{y = 2}
.
.
.
1{y = c − 1}
x; θ
=
ϕ
1
ϕ
2
.
.
.
ϕ
c−1
=
exp(θ
T
1
x)
c
j=1
exp(θ
T
j
x)
exp(θ
T
2
x)
c
j=1
exp(θ
T
j
x)
.
.
.
exp(θ
T
c−1
x)
c
j=1
exp(θ
T
j
x)
(5-45)
对应的似然函数为
L(θ) =
n
i=1
P(y
(i)
|x
(i)
; θ) (5-46)
对应的对数似然函数为
ℓ(θ) =
n
i=1
ln P(y
(i)
|x
(i)
; θ)
=
n
i=1
c
j=1
ln
exp(θ
T
j
x
(i)
)
c
t=1
exp(θ
T
t
x
(i)
)
1{y
(i)
= j}
=
n
i=1
c
j=1
1{y
(i)
= j}ln
exp(θ
T
j
x
(i)
)
c
t=1
exp(θ
T
t
x
(i)
)
(5-47)
5
这取决于你的激活函数选取
- 50 -
哈尔滨工业大学本科毕业设计（论文）
式(5-47)的相反数也被称为交叉熵，在训练过程中充当准则函数，我们对其求导，
有
∂ℓ(θ)
∂θ
j
=
n
i=1
c
j=1
1{y
(i)
= j}
x
(i)
−
∂
∂θ
j
ln
c
t=1
exp
θ
T
t
x
(i)
=
n
i=1
c
j=1
1{y
(i)
= j}
x
(i)
−
exp(θ
T
j
x
(i)
)
c
t=1
exp(θ
T
t
x
(i)
)
x
(i)
=
n
i=1
c
j=1
1{y
(i)
= j}x
(i)
1 − P(y
(i)
= j|x
(i)
; θ)
(5-48)
由于1{y
(i)
= j} ∈ {0, 1}，所以写成向量形式为
∂ℓ(θ)
∂θ
j
=
n
i=1
x
(i)
1{y
(i)
= i} − P(y
(i)
= j|x
(i)
; θ)
(5-49)
通过使用式(5-49)进行迭代，我们便可以使用梯度上升（下降）进行搜索，从而最
大化似然（或最小化交叉熵）来训练softmax分类器。
5.4.2 误差传播
为了简单起见，我们使用一个三层神经网络对误差传播进行讨论，但通过这
里的讨论，我们可以很容易将神经网络扩展到多层结构。
图 5-10 三层神经网络的网路构型
如图5-10中的三层神经网络，y层到z层为分类器，根据之前的讨论，我们可
以利用式(5-40)和式(5-41) 求取∂J(θ)/∂θ
yz
的值，如果我们要求取∂J(θ)/∂θ
xy
的值，那
么通过链式求导，我们有
∂J(θ)
∂θ
xy
=
∂J(θ)
∂y
∂y
∂net
y
∂net
y
∂θ
xy
(5-50)
而我们又可以求得
∂J(θ)
∂y
=
∂J(θ)
∂net
z
∂net
z
∂y
(5-51)
如果我们定义式(5-40)以及式(5-41)中的误差为
- 51 -
哈尔滨工业大学本科毕业设计（论文）
δ
z
=
∂J(θ)
∂net
z
(5-52)
那么我们可以将式(5-51)写为
∂J(θ)
∂y
= δ
z
∂net
z
∂y
= δ
z
θ
T
yz
(5-53)
式中，∂J(θ)/∂y就是分类器输出层（Z层）的误差传播回其上一层（Y层）的误差，
如果我们定义Y层的误差为
δ
y
=
∂J(θ)
∂y
∂y
∂net
y
(5-54)
则我们可以利用后一层传播回来的误差δ
z
计算该层的误差
δ
y
= δ
z
θ
T
yz
·
∂y
∂net
y
(5-55)
从而我们可以利用该层的误差δ
y
计算该层参数w
xy
的增量，即梯度
∂J(θ)
∂θ
xy
= δ
y
·
∂net
y
∂θ
xy
(5-56)
通过式(5-56)对参数θ
xy
进行校正，校正完毕后，如果网络不止三层，而是四层，假
设X层的下一层为P层，那么为了计算连接X层与P层参数θ
px
的梯度，利用链式求
导，同样有
∂J(θ)
∂θ
px
=
∂J(θ)
∂x
∂x
∂net
x
∂net
x
∂θ
px
(5-57)
与之前的做法类似，我们有
∂J(θ)
∂x
=
∂J(θ)
∂y
∂y
∂net
y
∂net
y
∂x
= δ
y
· θ
T
xy
(5-58)
同样的道理，X层的误差δ
x
定义为
δ
x
=
∂J(θ)
∂x
∂x
∂net
x
= δ
y
θ
T
xy
·
∂x
∂net
x
(5-59)
则参数θ
px
的梯度便可以利用δ
x
计算
∂J(θ)
∂θ
px
= δ
x
·
∂net
x
∂θ
px
(5-60)
如果还有更多的层，其原理雷同，我们不再详细叙说。现在让我们抛开以上的数
学内容从网络的结构上解释这个算法为什么叫做误差反向传播，首先我们观察各
层的误差，即
[δ
z
δ
y
δ
x
] =
∂J(θ)
∂net
z
δ
z
θ
T
yz
·
∂y
∂net
y
δ
y
θ
T
xy
·
∂x
∂net
x
(5-61)
式中，θ
T
起到的作用是将误差δ反向注入的行为，这个行为如图5-11所示
- 52 -
哈尔滨工业大学本科毕业设计（论文）
图 5-11 误差反向注入
观察式(5-61)，我们不难看出，除了最顶层外，剩余层的误差形式都是类似
的，如果用一句话概括反向传播算法，便是：将ℓ层的误差注入到ℓ − 1层中，再乘
上ℓ − 1层激活函数的导数，得到ℓ − 1层的误差，利用这个得到的误差，对ℓ − 1层
的参数进行更新，更新完毕后，将ℓ − 1层的误差重新注入到ℓ − 2层，重复上述步
骤直至误差传遍整个网络。但是这里有个例外，最顶层的误差定义与剩余层的不
一样，之所以会这样是因为最顶层的误差并不是通过注入方式得到的，而是人为
定义得到的，因为这个误差源自于准则函数。
我们可以看到，反向传播这种策略实际上与前向传播是类似的，反向传播也
是一种贪婪算法，这将会导致一些问题。因为每一次误差传播都是更新参数后再
将误差注入回前一层，这并不能保证计算得到的梯度就是真实的梯度，一旦网络
的层数过深，将会导致前面层的真实导数与利用反向传播计算得到的导数相差过
大。另外，如果使用sigmoid函数作为激活函数，它将很容易进入饱和状态，前面
层的梯度接近于0，从而参数无法更新，这种现象我们称之为梯度消失。一种对抗
梯度消失的方法是将sigmoid函数换成ReLU激活函数，关于ReLU为什么可以抵抗
梯度消失的原理目前尚未研究出来，但是实验现象表明它确实能抑制梯度消失。
5.5 深度置信网络
深度置信网路（Deep Belief Networks，简写为DBN）本质就是一种传统的神
经网络，但是它在传统神经网络的基础上加入一些变动。首先，这是一种深层
的神经网络，而传统的神经网络一般只设计为三层结构。另外，深度置信网络
是一个以受限玻尔兹曼机为基础，多个受限玻尔兹曼机垒出来的多层神经网络。
图5-12展示了一个深度为4的深度置信网络。
我们之所以采用深度结构，是因为在神经元总数不变的前提下，深度结构的
表达能力比浅结构的表达能力更强。之所以要在这个结构中引入受限玻尔兹曼机，
- 53 -
哈尔滨工业大学本科毕业设计（论文）
图 5-12 DBN网络构型
是因为传统的深度结构无法训练。正如我们前面提及到的，深度结构会在网络的
较浅层出现梯度消失现象，导致浅层无法对参数进行校正。由于数据必须从浅层
神经元逐层地传播到深层神经元，一旦浅层的参数无法校正，将会导致深层的网
络也无法进行参数校正，因为浅层参数无法校正意味着浅层无法对数据进行合理
地重编码，数据经过浅层后得到的是混乱的数据，尽管深层不会产生太大的梯度
消失现象，但数据经过浅层的打乱后，数据已经混乱了，训练也便没有意义。另
一方面，传统的神经网络初始值设定为随机值，这些随机值一般设定为一个均值
为0，方差较小的高斯分布，神经网络是一个非凸问题，局部最小值众多，网络最
后收敛到的最小值取很大程度上决于初始值的选取，随机选取初始值虽然是一个
可行的方法，但是如果我们能让参数的初始值设定在一个较合理的初始值，将会
很大程度地改善网络的收敛性能，而受限玻尔兹曼机一个重要的贡献在于，将深
度神经网络的参数初始化到一个较好的值。
深度置信网络的训练分为两个阶段，分别是预训练阶段和参数微调阶段。
在DBN的预训练阶段中，将相邻两层看做一个受限玻尔兹曼机，采用受限玻尔兹
曼机的训练方法，将原始数据作为最底层的输入，每层RBM隐含层的输出作为后
一层的输入，然后进行逐层贪婪的无监督训练。对于每层RBM，其训练过程描述
如算法5-1所示
- 54 -
哈尔滨工业大学本科毕业设计（论文）
Input: 由前一层网络提供的含有n个样本的数据
集S = {x
i
}
n
i=1
；网络参数w, b
h
, b
v
；动量项系数p；
学习率η；权衰减系数e；CD-k中的参数k
Output: 训练好的网络参数；
由RBM提取到的数据S
′
= {y
i
}
n
i=1
1 for i = 1;i ≤ 1; i + + do
2 v
0
= v
t
= x
i
3 h
0
= sampling h given v (v
0
)
4 for j = 0; j < k; j + + do
5 h
t
= sampling h given v (v
t
)
6 v
t
= sampling v given h (h
t
)
7 end
8 ∆
w
= v
T
t
∗ h
t
− v
T
0
∗ h
0
9 ∆
b
v
= v
t
− v
0
10 ∆
b
h
= h
t
− h
0
11 w = e ∗ (p ∗ w + η ∗ ∆
w
)
12 b
v
= b
v
+ η ∗ ∆
b
v
13 b
h
= b
h
+ η ∗ ∆
b
h
14 y
i
= sampling h given v (x
i
)
15 end
算法 5-1 受限玻尔兹曼机训练算法
算法5-1中，学习率η、动量项系数p以及权衰减系数e我们将会留到网络设计
技巧中讨论，这些技巧在数学推导的过程中是不必要的，然而在实际工程中是必
要的，有时候缺了它们网络训练会失败。当逐层训练完毕后，网络的参数已经初
始化到一个较好的位置
[34]
。在参数微调阶段，接着执行全局的反向传播算法进
行有监督的权值微调。通过这样的方法，可以避免单纯地使用反向传播方法中会
出现的陷入局部最优问题，由于识别的过程中，数据是逐层地进行维度变化，所
以DBN也可以认为是一种特征提取方法，对应的，深度学习有时候也称之为“特
征学习”
[35]
。
- 55 -
哈尔滨工业大学本科毕业设计（论文）
5.6 本章小结
本章中，我们从传统的神经网络说起，介绍了神经元的工作原理以及神经网
络的前向传播。当数据经过神经网络的逐层编码后，得到的编码并不是人类所能
理解的编码，因此我们介绍了两种分类器将这些编码转换成自然语言所能描述的
编码。随后我们介绍了神经网络的反向传播算法，最后引出深度置信网络。尽管
这章名为“深度置信网络”，我们却对“深度置信网络”的介绍篇幅很短，但由
于深度置信网络中并没有太多额外的东西，很多思想都是与传统神经网络是相同
的，所以我们花了较大的篇幅取介绍传统神经网络。在本章中，我们依然留下一
些问题没有解决，即训练过程中的一些额外参数，例如学习率、动量项等，关于
这些内容，由于其更偏向于工程内容，我们将其集中到“神经网络设计技巧”章
节中讨论。
- 56 -
哈尔滨工业大学本科毕业设计（论文）
第 6 章 卷积神经网络
卷积神经网络灵感源自哺乳动物的视觉系统，它是唯一一个不需要预训练便
能直接训练的深度网络。LeCun在1989年设计了第一个卷积神经网络，并将这个
网络运用到邮编数字识别中取得了很好的效果，随后，文献[19]将卷积神经网络
应用到文档识别中，实现了可理解数字串的网络，这是一个重大的突破，因为这
涉及到数字间的上下文。但卷积神经网络在提出的二十多年里一直默默无闻，直
到最近几年，人们发现在图像识别中卷积神经网络相比于其他的模型能更好地进
行特征提取才被重视。目前，几乎所有最好的识别系统都是基于卷积神经网络的，
从某种意义上而言，卷积神经网络相当于深度学习的代言人。
6.1 卷积神经网络综述
卷积神经网络可以看做是一种特殊的神经网络，在深度置信网络中，网络节
点是全连接的，而卷积神经网络中连接是局部的。此外，卷积网络强制权值共享，
对比于深度置信网络，卷积网络的这些特性都体现着非常强的正则。
a) 全连接神经网络 b) 卷积神经网络
图 6-1 二维视觉下的全连接神经网络与卷积神经网络
如图6-1 a)所示为传统的全连接神经网络，我们可以看到，每一个上层节点与
下层节点都含有连接，而所有的连接都是独立无关联的，即每个连接权值都不相
等。对应的，图6-1 b)所示为卷积神经网络，在这种网络构型中，每个上层节点只
与部分的下层节点连接，并且，这些连接的权值是共享的，即相同颜色的连接代
表其权值相等。局部连接将会大大减少网络的连接数量，而权值共享又会大大减
少网络的参数数量。例如在图6-1 a)中，连接数量为3 × 5 = 15，由于权值不共享，
其参数数量也是15。而图6-1 b)的连接数量为3 × 3，权值共享使得网络的参数只
有3个。卷积网络的设计目的是让网络拥有更多的连接，而拥有更少的权值。尽管
- 57 -
哈尔滨工业大学本科毕业设计（论文）
这里连接数量上卷积网络要比全连接网络少，但是我们后面将会看到，卷积网络
将通过多张特征图构造出更多的连接。
卷积神经网络，一般用于图像识别与声音识别两个领域，因为这两个领域带
着明显的二维特性。例如在图像识别中，图像即可以看做是高维的，也可以看做
是二维的，如果将它看做高维的，那么就是将像素点展开成为一个高维列向量，
展开后的图像将不再具有原始的面貌。如果将它看做是二维的，就是保留图像
的原貌，利用二维的平面直角坐标系来描述。声音之所以可以看做二维的，是因
为它带有时间这一维度，关于语音识别，我们不过多讨论，更多的细节请参考文
献[36–38]。
a) 全连接神经网络 b) 卷积神经网络
图 6-2 三维视觉下的全连接神经网络与卷积神经网络
由于卷积网络保留了图像的二维面貌，因此相比于全连接神经网络而言，其
网络构型是一个三维构型，如图6-2 a)所示为三维视觉下全连接神经网络。由于上
层节点是一个高维列向量，我们可以认为这个向量是一维的，并且这个向量里的
每一个元素都与输入图像上的每一个像素点连接，不同元素之间的连接权值是不
同的。而图6-2 b)所示是三维视觉下的卷积神经网络，我们可以看到，上层节点
是一个二维矩阵，因此它的特征我们可以认为是二维的，这些上层节点组成的二
维矩阵我们称为特征图（feature map），特征图里的每一个元素，都只与输入图像
上的一小块区域有连接，并且，特征图里的不同元素的连接权值是相等，这些相
同的连接权值我们称之为卷积核（convlution kernel）。图6-2 b)仅仅是一张特征图，
实际中的卷积神经网络，往往通过多个不同的卷积核，卷积出多张特征图。
- 58 -
哈尔滨工业大学本科毕业设计（论文）
6.2 卷积神经网络的前馈
一个完整的卷积神经网络应包含三个内容： 卷积层、采样层以及全连接层，
关于各层的细节以及作用我们将在后面的小节中叙述，现在让我们先大致了解卷
积神经网络的结构。如图6-3所示是卷积神经网络其网络构型
图 6-3 卷积神经网络网络构型
在这种结构中，卷积层与采样层交错出现，在网络顶端采用全连接神经网络
或其他分类器。图中卷积层里的每一张特征图，其执行过程都如图6-2 b)所示，这
些不同的特征图对应着不同的卷积核，多张特征图，增加了网络的连接数目，但
由于每张特征图只对应一个卷积核，所以网络的参数（即卷积核）的数目相比与
全连接神经网络参数的数目而言是很小的。
6.2.1 卷积
卷积神经网络所使用的卷积即二维离散卷积，其定义为
y[s, t] =
m
1
+m
2
−1
i=1
n
1
+n
2
−1
j=1
x[i, j] · k[s − i + 1, t − j + 1]
1 ≤ s ≤ m
1
+ m
2
− 1
1 ≤ t ≤ n
1
+ n
2
− 1
(6-1)
式中，x为m
1
× n
1
的矩阵，称为原始数据，x[i, j]代表x中的第i行第 j列元素。
k为m
2
× n
2
的矩阵，称为卷积核，k [i, j]代表k中的第i行第 j列元素。y为(m
1
+ m
2
−
1) × (n
1
+ n
2
− 1)的矩阵，称为卷积结果，y[i, j]代表y中的第i行第 j列元素。如果从
图像上来解释二维离散卷积，卷积层的操作相当于图6-4所描述的过程。图中，原
始图像是一张5 × 5像素的数字“4”的二值图像，如果我们定义卷积核为
kernel =
0 0 0
0 2 0
0 0 0
(6-2)
- 59 -
哈尔滨工业大学本科毕业设计（论文）
图 6-4 卷积神经网络网络构型
那么经过二维离散卷积后，其得到的卷积结果为
y = x ∗ kernel =
2 0 2
2 2 2
0 0 2
(6-3)
将卷积结果再经过一个阶跃函数进行非线性变换后，我们可以看到，卷积层通过
式(6-2)中定义的卷积核对原始图像（即数字4）进行卷积后，其非线性化后的结果
依然保留着数字4的特征。由于卷积核是固定的，因此卷积操作经常被认为是一种
滤波，即用卷积核去检测特征，将这些特征提取出来。
图6-4只是利用一个卷积核对原始图片进行卷积得到一张特征图，事实上，正
如图6-3所示，如果我们利用多个卷积核对原始图像进行卷积，那么便可以得到多
张特征图。多张特征图，意味着可以提取到原始图像的多个特征，例如在手写数
字识别中，我们提取了三张特征图，其中一张特征图表明左上角有一点，一张特
征图表明右上角有一个折线，剩下的一张特征图表明右下角有一个点，那么通过
这三张特征图，我们就可以判定这个数字是“7”。特征图的作用，在于降低数据
的冗余信息，例如“7”这个数字中，横线事实上只需要两个点就可以确定一条直
线，竖线也同理只需要两点便可确定一条直线，然而横线与竖线之间存在一个相
对位移，因此折线的作用便是刻画相对位移的。
图6-4中的例子只针对与原始输入数据是一张图像的情况，实际上，卷积操作
应该泛化到输入图像为多张的情况。例如，图6-3中的第二个卷积层，其输入图像
便是多张图像。实际中，输入图像也不太可能是一张图像，一张输入图像的情况
往往只出现于灰度图像中。然而在彩色图像中，我们知道，彩色图像是具有三张
矩阵的，分别代表红（R）、绿（G）、蓝（B）。对于输入图像为多张的情况，解决
- 60 -
哈尔滨工业大学本科毕业设计（论文）
的方法有两种。一种是利用同一个卷积核去卷积所有的n输入图像，将得到的n张
卷积结果进行相加合并成为一张，在将它进行非线性映射，从而得到一张特征图，
这个过程如图6-5所示。
图 6-5 使用同一卷积核卷积多张图像
另外一种解决方法是，假设我们有m张输入特征图，而我们想要卷积后得到n
张输出特征图，那么我们使用m × n 个卷积核，令k
i, j
代表从第i张输入特征图映射
到第 j张输出特征图这个过程中所需要使用的卷积核，b
j
代表卷积完成后第 j张特
征图所要加上的偏置，那么卷积操作就可以描述为：
M
1
, M
2
, ··· , M
m
k
1,1
k
1,2
, ··· , k
1,n
k
2,1
k
2,2
, ··· , k
2,n
.
.
.
.
.
.
.
.
.
.
.
.
k
m,1
k
m,2
, ··· , k
m,n
b
1
, b
2
, ··· , b
n
=
M
1
, M
2
, ··· , M
n
(6-4)
式中，
M
i
m
i=1
为m张输入特征图，
M
j
n
j=1
为n张输出卷积结果，为面向元素的加
法，是我们提出的一种运算，其运算与矩阵乘法类似，唯一不同是在元素操作
时，矩阵乘法执行的是乘法操作，而执行的是卷积操作。卷积操作完成后，再进
行非线性映射，即可得到多张特征图。式(6-4)实际上类似于全连接神经网络的前
向传播，但是不同的是，全连接神经网络中，m × n矩阵里的每一个元素代表连接
权值，是一个常数，而式(6-4)中，m × n矩阵里的每一个元素代表一个卷积核，是
一个矩阵。另外一个不同点在于，全连接神经网络执行的是乘法，而式(6-4)中执
行的是卷积。
事实上，第一种解决方案只是第二中解决方案的特例，在第一种解决方案中，
实际上相当于K
m×n
中的每一列都强制相等，即
k
1,1
= k
2,1
= ··· = k
m,1
(6-5)
因此，第一种解决方案意味着更强的正则，或者说更强的惩罚，因为它强制每一
列的卷积核都相等。但是我个人认为，尽管这种方法确实能工作得很好，但这是
- 61 -
哈尔滨工业大学本科毕业设计（论文）
不太合理的。例如在图像中，三个输入图像，也就是RGB三个矩阵，采用第一种
方案意味着对三个颜色都同等对待，因为作用在三个矩阵上的卷积核是相同的。
但我们直觉上可以感觉到，这三种颜色不应该同等对待，而应区分开来，因此在
往后的讨论中，我们只讨论第二种解决方案。
6.2.2 采样
卷积得到的特征图，需要经过一个采样层，采样层是针对每一张特征图的，
即各张特征图的采样时独立互不干扰的，因此采样得到的特征图与原始的特征图
之间是一一对应关系。假设我们使用一个均值采样，对于一个4 × 4的特征图，我
们对其每2 × 2区域内取平均，即
1 1 2 2
1 1 2 2
3 3 4 4
3 3 4 4
→
1 2
3 4
(6-6)
采样层的作用在于压缩数据，使得维度不至于快速增长。想象一个原本
为6 × 6像素的原始图片，在经过一个3 × 3的卷积核进行卷积后，得到的特征图大
小为4 × 4，但这只是一张特征图，由于在卷积层中我们往往使用多个卷积核进行
卷积，假设我们设定卷积层的输出特征图总量为50，那么将会有50 ×4 ×4 = 800个
节点，而原来的节点只有5 × 5 = 25个节点，这将会使节点增加了32倍。采样层一
般都是对卷积得到的特征图进行2倍的缩小，仅此经过采样层后，特征图的大小
为2 × 2，此时的节点仅为50 × 2 × 2 = 200个。
另一方面，采样层可以抑制位移的变化，卷积得到的特征图，在经过小区域
内的平均后，弱化了其绝对位置，而保留了其相对位置，需要注意的是，这里的
位移并不仅仅只欧式距离里的位移，还应包括图像的伸缩，旋转等，所以这个位
移应理解为广义的位移。
采样的方法除了上面提到的平均采样方案，还有一些别的方案，例如xxx文献
中介绍了一种自学习的采样，即小区域内并不是简单的求和取平均，而是类似于
加权求和取平均，这些权值便是所需要学习的参数。这两种方案并没有孰劣孰优
的说法，实际上两者都能很好的工作，但自学习的方法确实是会比简单的平均采
样好一些，但由于平均采样更简单，所以我们往后的讨论只使用平均采样。
- 62 -
哈尔滨工业大学本科毕业设计（论文）
6.2.3 分类器
原始输入数据经过多次卷积采样后，特征图的尺寸不断缩小，最后将使得卷
积无法再进行，此时，我们将这些非常小的特征图展开成为一个列向量。例如，
一个原始图片为32 × 32大小的图像，经过一个5 × 5大小的卷积核后得到28 × 28的
特征图，对其进行均值采样，将变为14 × 14大小的特征图，再用5 × 5大小的卷积
核卷积，将得到10 × 10 大小的特征图，采样后为5 × 5大小，此时再执行一次卷积
后，特征图大小为1 × 1，这时候再也无法进行采样了，假设现在有100个1 × 1大
小的特征图，那么它便可以展开成为一个100维的列向量。又例如，一个原始图
片为28 × 28大小的图像，如果卷积核都设定为5 × 5，那么经过卷积、采样、卷
积、采样后，将得到4 × 4的特征图，此时卷积核尺寸大于特征图的尺寸，卷积
无法执行，应将这些特征图展开，假设有10张4 × 4的特征图，那么展开后将得
到10 × 4 × 4 = 160维的列向量。
对于最后的列向量，即可以直接使用分类器，也可以在这些列向量的基础上
搭建几层隐含层后再使用分类器，这个分类器可以是全连接神经网络或支撑向量
机等，选取哪个取决于设计者的意愿。关于分类器如何使用，读者可以参考前面
的章节，在卷积网络最顶层的分类器中，与传统神经网络是相同的。
6.3 卷积神经网络的反馈
卷积神经网络的训练方法与传统神经网络的训练方法类似，都是采用反向传
播算法，但由于卷积网络特殊的构型，需要对其进行一些改动，但两者的核心都
是相同的，即通过后一层的误差注入前一层中，乘上该层激活函数相对于净激活
的偏导数后得到该层的误差，利用这个误差乘上净激活相对于输入的偏导数即可
得到参数更新的增量。唯一的不同点在于注入的方式不同。
6.3.1 分类器误差传播
由于卷积神经网络中最顶层与传统的神经网络相同，因此参数校正以及反向
传播方式是相同的。有一点需要注意的是，如果网络最后一个卷积层（或采样层）
中将特征图拉成一个列向量，那么反向传播的时候需要将列向量还原回特征图形
式，例如，如果网络中最后阶段得到10张4 × 4大小的特征图，前向传播过程中会
将它们合并成为一个160维的列向量，那么在反向传播过程中，需要将160维的误
差列向量还原成10张4 × 4的特征图形式，此时得到的特征图可以看做是误差特征
- 63 -
哈尔滨工业大学本科毕业设计（论文）
图。
6.3.2 采样层误差传播
在采样层中，如果我们使用平均采样，由于平均采样并没有额外的参数需要
学习，因此只需要将后一层传播回来的误差继续传播回前一层即可。由于采样层
是对前一层局部区域的平均，所以在将误差传播回前一层时，只需要将其尺寸放
大到相同的比例，对应的局部区域中每一个元素均取采样层中的元素即可。例
如，一个缩小比例为2的采样层，假设它接收到后一层传播回来的误差特征图尺寸
为2 × 2，那么这个误差传播回采样层的前一层将得到4 × 4尺寸的特征图，这个过
程如式(6-7)所示
1 2
3 4
→
1 1 2 2
1 1 2 2
3 3 4 4
3 3 4 4
(6-7)
如 果 读 者 在 此 之 前 了 解 过Kronecker积 （也 称 直 积）， 上 述 过 程 便 是 一
个Kronecker积过程，即
δ
conv
= δ
sampling
⊗ 1
n×n
(6-8)
式中需要注意的是，⊗是直积符号而不是逻辑电路里的异或符号。δ
conv
代表传播回
前一层（即卷积层）的误差，δ
sampling
代表后一层网络传播到采样层的误差，1
n×n
是
一个n × n的单位向量，n的取值等于采样层的缩小比例，例如，如果采样层的缩小
比例是2，则n = 2。
6.3.3 卷积层误差传播
与传统的全连接神经网络类似，卷积层接收到后一层传播回来的误差后，需
要乘以当前层激活函数相对于净激活的偏导数，得到当前层的误差，即
δ
ℓ
i
= δ
ℓ+1
i
·
∂ f (net
i
)
∂net
i
(6-9)
由于卷积网络中有多张特征图，所以δ
ℓ
i
代表当前层（ℓ层）的第i张误差特征图，
δ
ℓ+1
i
代表第ℓ + 1 层传播回来的第i张误差特征图，net
i
代表第i张特征图的净激活。
计算得到当前层的误差后，通过卷积的自相关性，利用这个误差可以计算卷
积核以及偏置的迭代增量，即
[39]
- 64 -
哈尔滨工业大学本科毕业设计（论文）
∂J
∂k
ℓ
i, j
= rot180
conv
x
ℓ−1
i
, rot180(δ
ℓ
j
),
′
valid
′
(6-10)
式中，rot180(·)执行将一个矩阵旋转180
◦
操作，其目的在于利用卷积的自相关性
质，conv为卷积操作，‘valid’代表卷积操作范围限制在可用区域内。对于偏置，
其梯度为
[39]
∂J
∂b
j
=
u,v
(δ
ℓ
j
)
uv
(6-11)
获取参数的梯度后，对卷积层的参数进行更新，随后将卷积层的误差反向传播到
采样层，其公式为
[39]
δ
ℓ−1
j
= f
′
(u
ℓ
j
) conv
δ
ℓ
j
, rot180
i∈M
ℓ
j
k
ℓ
i j
,
′
f ull
′
(6-12)
式中，为面向元素的乘法，‘full’代表卷积的操作范围是全图卷积。通过以上策
略，对网络进行类似的反向传播，即可对整个网络进行反馈校正。
6.4 本章小结
本章中我们介绍了卷积神经网络中卷积层以及采样层的原理，并介绍了一
种卷积神经网络的结构。卷积网络的结构变体有很多，1989年LeCun设计的第一
个卷积神经网络仍带有轻微的全连接网络气息
[18]
，而1998年LeCun与Bengio等人
设计的卷积神经网络在卷积时并不是全特征图卷积，而是选取一部分的特征图
进行卷积
[19]
。Lee Honglak与Andrew Ng等人将受限玻尔兹曼机与卷积神经网络相
结合，形成一种名为Convolutional deep belief networks的神经网络
[40]
。文献[41]中
介绍了一种使用三维卷积核的卷积网络，因此这种网络可以看做是四维网络，
Krizhevsky等人利用它在2012年的ImageNet LSVRC-2010数据集上获得了世界第一
的正确率，这种卷积网络成为当前的主流结构。尽管卷积网络的变体众多，但其
大体思路是类似的，都是基于卷积核对局部特征进行提取。
- 65 -
哈尔滨工业大学本科毕业设计（论文）
第 7 章 神经网络的设计技巧
神经网络的设计技巧众多，这些技巧大致可分为两大类，一类是训练前对数
据的预处理，另一类是训练过程中采用的一些特殊的训练手段。数据预处理的作
用在于将原始数据处理成容易训练的数据，加快准则函数的收敛速度，另一方面，
原始数据的降维可以在牺牲较小精度的前提下减少运算量，提高程序的执行效率。
训练过程中采用的一些特殊手段在数学上是没有太大意义，甚至有时候是违反直
觉的，这些技巧是多年来科研人员积累出来的经验，其灵感来源一般靠蒙。尽管
这些经验有时候反而会降低网络的性能，但大部分情况下确实会提高性能的，某
些情况下，不适用这些技巧，网络的训练初始阶段准则函数无法收敛。具体设计
过程中，对于这些技巧，我们应该抱着试一试的心态，如果在网络中使用某个技
巧，使得网络性能变好了，那么我们便保留这个技巧，否则如果网络性能变差了，
那么就舍弃这个技巧
1
。
7.1 数据预处理
数据的预处理大致可分为几类：白化、降维、扩容、归一化。白化的作用在
于去除数据耦合的相关性，降维的作用在于压缩数据，加快算法执行效率，由于
主成分分析是一种去除相关性的降维方法，因此我们将白化合并到主成分分析
的章节中而不另起章节。扩容目的在于利用一些手段，人工地伪造一些训练数
据，将训练样本的容量扩大，使得网络的泛化能力变强。归一化的目的在于让
数据保持在[0, 1]区间内，之所以要在这个区间内，一方面，在一些激活函数，比
如Sigmoid函数中，如果数据尺度过大，则使得激活函数迅速饱和，从而梯度接近
于0，权值更新缓慢。而数据归一化到较小的数值上时，我们知道，Sigmoid函数
在原点附近是一个近似于线性的函数，在训练的初始阶段便可让权值获得较大的
梯度。另一方面，如果数据尺度过大，有可能会导致计算机的数值溢出，尤其是
激活函数为Sigmoid的时候，因为这个激活函数带有一个指数项，对于某些不自
带溢出检测的编程语言如C++而言，这是一场灾难，因为它会导致你的代码莫名
其妙地失败。即使是一些带溢出检测的语言，如Python，当数值溢出时，往往使
用Inf或NaN代替，此时进行的不再是数值运算，而是符号运算，这将极大地降低
运算速度。
1
但前提是这个技巧被正确使用，即编码正确
- 66 -
哈尔滨工业大学本科毕业设计（论文）
7.1.1 降维
人是一种受限于三维空间的动物，我们只能理解三维的而无法想象更高维度
的事物。事实上，人同样无法理解二维的或一维的世界，尽管我们可以在脑海中
想象二维曲面或一维曲线，但人脑海里的这些事物这些都不是二维，他们只是嵌
在三维空间中的二维（或一维）流形
2
。一张一百万像素的图片，它总能对应着一
百万维空间中的某一点，而很多张某个类比的图片，比如狗的图片，将会对应着
一百万维空间中的多个点。然而并不是一百万维空间中的任何一点都是狗的图片，
它也有可能是猫的图片，但是同样是狗的图片，它会在总会有某些共通性，这些
共通性，或者说特征，使得狗这一类图片在一百万维的空间中构成一个流形，如
果我们能找到这个流形，那么我们就可以避开一百万维空间，直接在低维流形中
进行分类。
由于我们无法理解高维空间，因此我们通过一个三维空间中的二维流形简单
叙述这件事，如果我们通过式(7-2)求取三维空间中任何一点的(x, y, z)坐标
α = 1.5π ∗ (1 + 2 ∗ random) (7-1)
x = α ∗ cos α y = 21 ∗ random z = α ∗ sin α (7-2)
式中，random是[0, 1]区间内均匀分布的随机数，那么我们就可以得到一个称为
“swiss roll”的散点图，如图7-1所示 如果这些点分别代表一个三维的数据样本，
那么我们可以发现，这些样本坐落于一个二维流形中，即图7-1中卷筒蛋糕的形
状。这里我们用了错误的措辞，因为流形实际上是一个空间而不是一个形状，
但为了通俗地解释这件事，我们认为采用这种措辞是可取的。观察式(7-2)，我
们可以发现，事实上三维空间中的点(x, y, z)可以只用二维空间的(α, y)描述，因
为x和z都是α的函数，从图像上我们也可以直观的感受到，三维数据是多余的，因
为数据的坐落位置十分有规律。
降维，也是同样的思想，高维的数据是带有冗余的，如果我们能找到这些数
据的低维流形，那么就可以在低维空间中进行数据处理。这衍生出了机器学习的
一个流派—流形学习。关于流形学习我们不会做过多的介绍，我们只在本章中介
绍两种降维方法，即主成分分析和多维尺度分析。与统计学习类似，实际中我们
也无法找到数据真实的低维流形，不同的降维方法相当于对低维流形的不同逼近
方法。如果说数据背后确实存在一个低维流形，而我们的降维方法又恰好是这个
2
更多有意思的观点可以观看麻省理工学院的《量子力学》公开课
- 67 -
哈尔滨工业大学本科毕业设计（论文）
图 7-1 Swiss Roll
流形的描述，那么降维不会引入信息的损失，例如，三维坐标降到球坐标并不会
引入误差，但实际中我们我们并不知道具体流形，我们的降维方法也不是真实的
维度变换方法，所以实际中的降维一定会引入信息的损失，导致分类性能的下降，
相比于降维带来的巨大好处—-运算效率的提高，这个性能的下降是可接受的。图
像识别，由于生活图像其维度都以千万记，降维是必须的，否则以目前的计算机
性能无法完成准则函数的收敛。
7.1.1.1 主成分分析
为了简单起见，我们只在这里讨论如何使用主成分分析将二维空间中的数据
降到一维空间，但二维空间中的结论很容易被推广到更高维度的情况，因为更高
维度空间中的结论与二维空间中的结论是相同的。
假设我们有一个含有n个2维样本的数据集X = [x
(1)
, x
(2)
, ··· , x
(n)
]
T
，如图7-2所
示是一个含有100个样本的数据集在平面直角坐标系上的分布。
如果我们通过计算得到这些样本点的均值 ¯x，即
¯x =
1
n
n
i=1
x
(i)
(7-3)
正如图7-2中的红点，那么我们总能将所有的点用一组基的线性组合来代替，即
x
(i)
= ¯x + α
1
e
1
+ α
2
e
2
(7-4)
- 68 -
哈尔滨工业大学本科毕业设计（论文）
图 7-2 二维空间中的数据样本点
式中，e
1
和e
2
是任意两 个不 平 行的 单位 向量，正 如图7-2中 的紫 色 方向 和绿 色
方向。但此时我们只是将样本点从一个原始的正交二维坐标系转换到另一个
以e
1
和e
2
为基的二维坐标系，为了降维，我们必然需要舍弃一个维度，这个维度可
能是e
1
或e
2
，然而选取哪个维度更好呢？ 直觉上我们会认为选取e
2
会更好，因为当
所有的数据点都投影到这个基上时，相比于e
1
能更好地保留数据的信息。
然而，e
1
和e
2
是我们任意选取的两个基向量，事实上有可能有另外的基向量
要比e
1
更好的保留原始数据的特征，假设最优的基向量为e，那么为了刻画数据降
维后原始数据与降维后数据的差异性，我们引入一个准则函数
J(α
1
, α
2
, ··· , α
n
) =
n
i=1
( ¯x + α
i
e) − x
(i)
( ¯x + α
i
e) − x
(i)
T
(7-5)
式中， ¯x + α
i
e实质上代表的是原始数据降维到一维空间后在二维空间中的坐标，
即原始数据在基向量e的投影点的二维坐标。准则函数使用的依然是我们非常熟
悉的二范数，这个准则函数事实上刻画的是原始坐标到投影坐标距离的平方，也
就是两者究竟相差了多远。为了最小化这个准则函数，我们先对式(7-5)进行展开，
这将得到
J(α
1
, α
2
, ··· , α
n
, e) =
n
i=1
α
2
i
||e||
2
− 2
n
i=1
α
i
e
T
(x
i
− ¯x) +
n
i=1
||x
i
− ¯x||
2
(7-6)
由于
n
i=1
||x
i
− ¯x||
2
只与数据相关而与参数无关可以舍去，此外，e是单位向量，所
以||e||
2
等于1，因此准则函数可以简写为
J(α
1
, α
2
, ··· , α
n
, e) =
n
i=1
α
2
i
− 2
n
i=1
α
i
e
T
(x
i
− ¯x) (7-7)
为了最小化这个准则函数，我们对其求偏导，并另导数为0，则
- 69 -
哈尔滨工业大学本科毕业设计（论文）
∂
∂α
i
= 2α
i
− 2e
T
(x
i
− ¯x) = 0 (7-8)
因此当α
i
= e
T
(x
i
− ˆx)准则函数取得最小。这实质上说明，当数据点投影到e时使得
准则函数最小，与我们前面的猜测符合。将(7-8)代回(7-7)，我们便可以消去准则
函数中的n个变量α
1
, ··· , α
n
，只剩余一个变量e，即
J(e) = −
n
i=1
e
T
(x
i
− ˆx)(x
i
− ˆx)
T
e (7-9)
如果我们记号散布矩阵为
S =
n
i=1
(x
i
− ˆx)(x
i
− ˆx)
T
(7-10)
则准则函数可以谢伟
J(e) = −e
T
S e (7-11)
此时是一个约束优化问题，约束条件为等式约束e
T
e = 1，为此引入拉格朗日乘
子λ，构造拉格朗日函数为
L(e) = −e
T
S e + λ(e
T
e − 1) (7-12)
对拉格朗日求偏导，并另偏导为0
∂
∂e
L(e) = −2S e + 2λe = 0 (7-13)
此时说明，当S e = λe时，准则函数最小，而事实上这是矩阵对特征根的定义，因
此为了最小化准则函数，基向量e应当选取为散布矩阵S 的特征向量。这个结论可
以很容易推广到高维情况，假设我们有n个d维的数据样本，那么我们总能构造他
的散布矩阵S ，为了将它降到k维而同时又要使得准则函数最小化，我们应该选
取S 最大的k个特征值所对应的特征向量作为投影基，从而新的k维坐标为
α
i
= e
T
(x
(i)
− ˆx) (7-14)
由于特征向量之间是正交的，因此降维后的数据在各个维度是独立的，这也
是白化的目的，因此主成分分析也是一种白化方法。有时候我们需要将降维后的
数据还原回原始的维度以检测降维后的数据究竟损失了所烧信息，那么利用特征
向量的正交性，有
eα
i
= ee
T
(x
(i)
− ˆx) = x
(i)
− ˆx (7-15)
此时等号两边同时加上均值 ˆx即可还原出d维数据。如图7-3所示是28 × 28像素的图
像，它共有784维，其原始数据为黑底的图像所示。如果我们使用主成分分析将其
降到20维后再将其还原成784维数据，其图像如灰底图像所示，我们可以看到，经
- 70 -
哈尔滨工业大学本科毕业设计（论文）
过降维后再还原的数据已经变得模糊化，而这些模糊化并不会影响我们对数字的
识别。
图 7-3 经过主成分分析降维后还原的数据
7.1.1.2 多维尺度分析
在介绍多维尺度分析
[42]
之前，我们先从地图重构的问题讲起。假设我们
在中国地图中选取五个城市，分别为北京、上海、广州、兰州、哈尔滨，依次
用A、B、C、D、E代替。如果我们以北京为坐标平面的原点，那么剩下的城市坐
标分别为：上海(631.6, −796.4)、广州(103.8, −2029.2)、兰州(−1228, −428.1)、哈尔
滨(265, 1082)，将这些城市的坐标描绘在平面直角坐标系上的结果如图7-4 a)所示。
另外，我们可以通过计算得到这五个城市的两两距离如图7-4 b)所示。
a) 城市分布图 b) 城市间两两距离
图 7-4 五个城市的信息
如果现在我们不再知道各个城市的具体坐标，我们只知道图7-4 b)中两两城市
之间的距离，那么如何通过图7-4 b)中的信息进行地图的重建，或者说根据距离推
导出各个城市的坐标呢？ 这就是多维尺度分析所要完成的工作。
首先，我们假设这n个城市的坐标构成一个矩阵X = [x
1
, x
2
, ··· , x
n
]
T
，那么城
市i和城市 j之间的欧式距离的平方为
- 71 -
哈尔滨工业大学本科毕业设计（论文）
s
i j
= (x
i
− x
j
)
T
(x
i
, x
j
) (7-16)
由s
i j
可以构成一个n × n的矩阵S
n×n
，这个矩阵我们称为距离矩阵，如果我们再定
义Gram矩阵为
G
n×n
= HXX
T
H (7-17)
其中，H为去中心化矩阵，定义为
H = I
n
− ee
T
(7-18)
其中，I
n
为n阶单位矩阵，e =
1
√
n
(1, ··· , 1)
T
，那么Gram矩阵可以推导为
G
n×n
= HXX
T
H =
(x − ¯x)
T
(x − ¯x)
(7-19)
式中， ¯x为X的均值，通过式(7-19)，进一步可以推导得
G
n×n
= −
1
2
HS H (7-20)
由于欧几里得距离是正定的，因此Gram矩阵也是正定的，如果我们将Gram矩阵特
征分解，则有
G
n×n
= PΣP
T
(7-21)
式中，Σ为Gram矩阵特征值构成的对角矩阵
Σ =
λ
1
.
.
.
λ
n
(7-22)
P为Gram的特征向量构成的矩阵，即P = [p
1
, ··· , p
n
]。如果我们提取出Gram矩阵
最大的k个特征值以及其对应的特征向量，那么通过
ˆ
X =
√
λ
1
.
.
.
√
λ
k
[p
1
, ··· , p
k
] (7-23)
我们将得到含有n个k维向量的矩阵
ˆ
X，这个矩阵
ˆ
X就是X在k维空间的一个映射。例
如，在我们地图重构的问题中，通过图7-4 b)中的距离信息，当k = 2时，我们求得
ˆ
X =
−45.6 434
−677.1 −362.1
−149.3 −1594.9
1182.5 6.2
−310.5 1516.5
(7-24)
- 72 -
哈尔滨工业大学本科毕业设计（论文）
如果将上述求得的坐标描绘在平面直角坐标系上，其结果如图7-5 a)所示。我
们可以看到，这些点与真实分布十分相似，只相差一个水平镜像，我们将其镜像
后的结果如图7-5 b)所示。镜像结果显示，重构的地图中，各个城市所在的相对位
置与真实地图中城市的相对位置相同，但是不同的是，在重构的地图中，绝对位
置改变了，例如我们可以看到，原来处于原点位置的北京现在不在处于原点。
a) 重构后得到的直接结果 b) 镜像后的结果
图 7-5 多维尺度分析对地图的重构
地图重构的例子并没有展现出多维尺度分析是如何降维的，因为这里只是从
一个二维坐标转换到另一个二维坐标。但由于这个转换的过程中使用的欧几里
得距离对于高维空间是可复用的，因此对于多维尺度分析的降维，我们先通过高
维空间中的数据点两两求距离，得到平方距离矩阵，在通过这个平方距离矩阵求
取Gram矩阵，将Gram矩阵特征分解，选取最大的k个特征值以及对应的特征向量，
利用他们可以将原始的高维数据降到k维数据。例如，图7-6描述了三维空间中的
数据降到二维空间的过程。
a) 三维空间中的原始数据 b) 降到二维空间后的数据
图 7-6 多维尺度分析的降维
- 73 -
哈尔滨工业大学本科毕业设计（论文）
多维尺度分析并不是一个应用非常广泛的降维方法，其主要原因在于欧几里
得距离，如图7-7三维空间中AB两点，如果使用欧几里得距离（图中的绿线），那
么我们认为这两点是十分接近的，因此降到二维空间后这两点将会靠得很近。但
事实上AB两点相距很远，它们两者之间经过很长一段流形（图中的红线），而欧
几里得距离忽视了这种距离。
图 7-7 Swiss Roll
尽管多维尺度分析并不常用，但是通过它可以引入流形学习中的一些经典算
法，例如Isomap等，用以解决图7-7中类似的情况，更多的讨论可参考文献xxxx
7.1.2 扩容
机器学习业内有一个共识，很多时候别人的分类性能比你的好并不意味着他
的算法比你的好，更大的可能是他拥有比你更多的数据。数据是统计机器学习的
命脉，没有数据，再好的模型也难以奏效。如果把机器学习中的算法比作是航天
器的引擎，那么数据就是航天器的燃料。这种现象在深度学习中尤为明显，特别
是卷积神经网络。深度学习需要大量的数据样本，这个需求量随着识别任务复杂
性的增加而增加。尽管互联网的大数据时代数据容易获取，但有些时候数据是有
限的，对于有限的数据集，我们可以通过一定的手段将数据集的容量扩大。例如
在字符识别任务中，我们知道，字符微量的扭曲、旋转、放大、缩小对人而言是
- 74 -
哈尔滨工业大学本科毕业设计（论文）
不会影响字符的识别，因此，我们可以对原始数据进行随机地选取上述一个或多
个变换，使得数据的容量增大
[43]
。又例如，真实生活中的图片，水平镜像、对比
度微调、饱和度微调等操作对人而言不影响最终的图像识别，我们利用这个特性
对图像采取一定的变换便可很大程度地增大训练集的容量，例如，仅仅是图像的
水平镜像就可以使得数据集扩大一倍。
数据的扩容，实质上是一种贝叶斯先验，因为我们对数据采取的变换策略不
会影响最终的分类，例如，我们不会对字符进行镜像处理。这种先验，使得模型
可以免疫一定的干扰，例如采取了水平位移变换策略的数据集受到水平位移的影
响就减小了，这就提高了模型的泛化能力。
7.2 训练技巧
网络的训练过程中，我们会使用到一些技巧，这些技巧大部分的目的都在于
抑制网络的过拟合以及防止准则函数陷入局部最优解。由于这些技巧众多，我们
无法在这里涵盖所有，因此我们只挑选了几个常用且重要的技巧，分别是学习率
的设定、动量项的使用以及权衰减。
7.2.1 学习率
在梯度下降算法中，每次求得准则函数相对于参数的梯度∂J/∂θ后，我们并不
是直接以这个值作为参数的增量，工程中，我们还应对梯度乘上一个学习率η，即
参数更新的公式为
θ = θ − η
∂J
∂θ
(7-25)
学习率的作用类似于下山时步伐的长度，步伐过长，则有可能导致准则函数震荡，
影响收敛速度，如果步伐十分大，则会导致发散现象，哪怕准则函数是凸函数，
存在唯一极值点，过大的学习率也会使其发散。例如，假设准则函数设定为二次
函数，即
J(θ) = θ
2
(7-26)
显然这是一个凸函数，存在唯一极值点，即θ = 0处。如果我们对这个准则函数求
偏导，则为
∂J
∂θ
= 2θ (7-27)
即准则函数J(θ)上的每一点θ，其梯度都等于2θ。假设现在θ = 2，那么我们可以
很容易计算得到其梯度为4，此时，最优的学习率为η
∗
= 0.5，因为2 − 0.5 × 4恰
- 75 -
哈尔滨工业大学本科毕业设计（论文）
好使得θ落入到最优解即θ = 0处，如图7-8 a)所示。如果我们的学习率选取得
比最优学习率大，假设 我 们 选 取 为η = 0.7，那么参数θ就会沿着2 → −0.8 →
0.32 → −0.128 ···的轨迹下降，如图7-8 b)所示。倘若我们的学习率再大一些，为
两倍的η时，即当η = 1时，θ就会在+2和−2两者之间变换而不会进入别的位置，
如图7-8 c)所示。当学习率大于两倍的最优学习率，例如η = 1.5，那么θ就会沿
着2 → −4 → 8 → −16的轨迹移动，此时准则函数便发散，这个过程如图7-8 d)所
示。
a) η = 0.5 b) η = 0.7
c) η = 1 d) η = 1.5
图 7-8 不同的学习率对收敛的影响
但是较大的学习率并不意味着一无是处，学习率稍微大一些，可以加快收敛
速度，而且可以越过一些局部极小值（但是对于高尔夫球场形状的局部极小值无
能为力）。在工程中，学习率的选取我们的建议是，先将学习率初始化为一个较大
的数值，如果准则函数发散了，那么我们就将其缩小2倍，直到准侧函数能开始下
降为止。另外一种做法是，先初步计算梯度的数值大小，将学习率设定为一个比
梯度小3个数量级的常数，例如，我们上面的计算得到的梯度是4，那么学习率可
以设定为0.001。
- 76 -
哈尔滨工业大学本科毕业设计（论文）
事实上学习率固定为一个常数并不是一个较好的策略，因为初始时设定的学
习率相对于训练的后期而言是过大的，这将会导致准则函数在极小值附近震荡。
一种解决方法是将学习率也设定为一个学习参数，这个参数随着网络的训练而不
断地更新，另外一种虽然愚蠢但行之有效的方法是，不断地关注准则函数的下降
情况，一旦感觉下降开始出现震荡或平谷现象就将学习率调小1个数量级。
7.2.2 动量项
很多时候，在参数校正的过程中，仅仅使用学习率是不行的，一般还应使用
动量项。动量项，即在参数的更新过程中，引入一个动量因子，更新规则描述为
θ
t+1
= θ
t
− η(1 − p)
∂J(θ)
∂θ
t
− p ∗ (θ
t−1
− θ
t−2
) (7-28)
式中，t 代表第t次参数更新，η为学习率， p为动量项因子，这个因子一般选取
为p = 0.9。式(7-28)实际上讲述了这样一件事：参数更新的时候，增量不仅仅依赖
于当前的梯度，还依赖于上一次权值变化量的p倍，因此参数的更新，带着类似于
物理中动量的项，即p ∗ (θ
t−1
− θ
t−2
)，它也被称之为动量项。动量项可以使得准则
函数快速地下降，并且可以越过一些较为平坦的局部极值。如果读者有数字信号
处理的背景，式(7-28)实际上是一个脉冲响应低通滤波器，目的在于平滑参数的更
新过程
[3]
。
但由于(7-28)需要记录上一次的参数增量，这在实际编码中需要一定的内存，
而且实现起来也不方便，另外一种关于动量项的简单用法是
θ
t+1
= pθ
t
− η
∂J(θ)
∂θ
t
(7-29)
式中，p为动量项系数，一般取0.9。动量项的使用，确实可以在一定程度上避免
局部最优解，例如，假设准则函数为
J(θ) = −5θ
3
− 80θ
2
− 400θ − 700 (7-30)
我们可以很容易地计算准则函数在任意一点的梯度为
∂J(θ)
∂θ
= −15θ
2
− 160θ − 400 (7-31)
假设学习率设置为常数0.001，如果不采用动量项，即参数更新的规律为
θ = θ − 0.001
∂J(θ)
∂θ
(7-32)
那么准则函数的收敛过程如图7-9 a)所示，我们可以看到，在收敛的后半阶段，参
数θ会收敛到局部极值，但如果我们使用一个系数为0.9的动量项，即参数更新规
则为
- 77 -
哈尔滨工业大学本科毕业设计（论文）
θ = 0.9 ∗ θ − 0.001
∂J(θ)
∂θ
(7-33)
此时的准则函数收敛过程如图7-9 b)所示，我们可以看到，动量项的引入，使得参
数θ在平坦的局部极值区域内依然带有冲劲，这个性质使得它可以跨越一些较小的
局部极值而不至于陷入其中。
a) 不使用动量项 b) 使用系数为0.9的动量项
图 7-9 动量项对收敛的影响
7.2.3 权衰减
谓权衰减，即在权值更新完毕后对所有的权值乘以一个小于1的常数e，e一
般取0.999左右。之所以要这样做的原因，是因为我们希望权值保持在较小的范围
内，因为更小的权值使得净激活停留在激活函数的非饱和区域内。使用权衰减的
参数更新规则为
θ = e ∗ θ (7-34)
关于权衰减的另一种解释是，在准则函数中，我们加入一个二范数惩罚，即新的
准则函数定义为
J
new
(θ) = J(θ) +
λ
2
θ
T
θ (7-35)
(7-35)中的第二项也被称为正则项。如果我们对式(7-35)求导，则为
∂J
new
(θ)
∂θ
=
∂J(θ)
∂θ
+ λθ (7-36)
因此权值的更新规则为
θ = θ −
∂J
new
(θ)
∂θ
=
θ −
∂J(θ)
∂θ
− λθ (7-37)
这事实上等价于是式7-34，即在权值更新后乘上一个衰减系数。我们之所以
使用权衰减，或者说加入二范数正则（这两个命题等价），实际上它代表着一种贝
- 78 -
哈尔滨工业大学本科毕业设计（论文）
叶斯先验，即我们对于权值的期待（希望它是较小的值）。
需要注意的是，在神经网络中，我们一般只针对权值进行权衰减，而不针对
偏置进行权衰减，因为我们希望获得较大的偏置。至于为什么，这实际上并没有
为什么。
7.3 编码技巧
尽管我们讨论了大量的理论内容，这些理论内容具体实现在代码上并不是一
件简单的事。代码如何设计以及如何测试是我们遇到的最大问题。与传统的软件
工程所不同的是，机器学习中的测试无法使用单元测试，因为在单元测试中我们
需要知道代码的期望输出，机器学习自学习的特点注定了我们无法知道其正确输
出是什么。代码的测试，更多时候是凭感觉，尽管如此，我们还是有办法进行一
些简单测试的，在本小节中，我们将会介绍面向对象的设计思路以及用于测试的
梯度校验。
7.3.1 面向对象技术
神经网络的设计中，不同层可以采用不同的激活函数，也可以采用不同的网
络结构，例如卷积层或全连接层。这些不同层之间都有两个共同的特性。在前向
传播过程中，无论是什么形式的层都接收前一层传播的激活，而在反向传播过程
中，所有的层都接收后一层传播回来的误差，并利用该层的输入与输出对参数进
行校正。尽管不同结构的网络层其校正方式不同，但这个过程可以使用面向对象
的技术实现。为了方便讨论，我们将用JAVA的语法来描述这个过程
3
。我们定义一
个接口Layer，它含有两个方法，即fprop和bprop，分别对应着前向传播和反向传
播。fprop接收一个参数，即前向传播得到的输入数据，bprop接收三个参数，分别
是反向传播回来的误差、该层的输入以及该层的输出，事实上，bprop也可以设定
为只接收一个参数，即反向传播回来的误差，而该层的输入以及该层的输出设定
为成员变量。具体的网络结构，例如ConvlutionLayer、FullConnectLayer等实现这
个接口，并实现这个接口中的两个方法，利用多态性，就可以容易地实现不同层
执行不同的更新方法。如果网络的所有层都采用同一个激活函数，那么这个激活
函数可以直接写到接口中（尽管JAVA要JDK9中才能在接口中提供方法的实现，但
我们可以利用继承让具体的层继承另一个类）。如果网络的所有层采用的是不同的
激活函数，那么我们可以通过策略模式将激活函数抽象成一个接口，具体的激活
3
然而JAVA并不是一门适合数值运算的语言
- 79 -
哈尔滨工业大学本科毕业设计（论文）
函数实现这个接口，在具体网络层实现类的构造方法中通过依赖注入将具体的激
活函数实现注入到网络层的类中，利用多态性，可以让不同的层执行不同的激活
函数，而这些不同的激活函数又可以实现代码复用。最后将这些不同的网络层组
合到一个神经网络实现类中，例如CNN或DBN，即可完成整个网络的编码工作，
整个工程代码的UML图如图7-10所示。
图 7-10 神经网络类图设计
7.3.2 梯度校验
在神经网络的编码中，一个令人头疼的问题是反向传播是否已经被正确编
码。很多时候，错误的编码并不会导致严重的错误，但它会影响最终的分类效果。
在debug过程中，一个十分有效的用来检测编码是否正确的方法是梯度校验。假设
我们要优化以θ为参数的准则函数，在梯度下降中，我们的更新规则如式(7-25)所
示。假设我们通过算法计算得到准则函数相对于参数的梯度，例如，在全连接神
经网路中，这个梯度一般为
∂J(θ)
∂θ
= δ ·
∂ f (net)
∂net
∂net
θ
(7-38)
式(7-38)本质上是利用导数公式取计算梯度，正如我们要算J(θ) = θ
2
的导数，那么
我们可以通过其导数即J
′
= 2θ 直接计算在某点处的导数，但我们还可以通过另一
种方式计算导数。回想高等数学中关于导数最原始的定义，导数即增量的极限，
定义为
∂J(θ)
∂θ
= lim
∆θ→0
J(θ + ∆θ) − J(θ)
∆θ
(7-39)
也就是说，如果我们给某个参数θ
i
加上一个非常小的增量∆θ，假设为0.001，那么
利用式(7-39)的原理，我们对比θ
i
没有加上这个增量之前准则J(θ)的值与加上增量
- 80 -
哈尔滨工业大学本科毕业设计（论文）
之后准则的值，这两个值作差，再除以增量，将会得到准则函数相对于θ
i
这个变
量的梯度。这种方法求得的梯度∆
∗
θ
J(θ)与利用式(7-38)∆
θ
J(θ)满足如下关系
∆
∗
θ
J(θ) ≈ ∆
θ
J(θ) (7-40)
如果∆θ取得足够小，那么这两者近似程度非常高，但是实际编码中∆θ不应取
得过小，因为计算机的浮点运算会带来误差，一般而言，∆θ取0.001左右就足以用
来验证梯度了。另外需要注意的是，这种近似性只会在较深的层中发生，在较浅
的层中误差会较大，因为反向传播是贪婪的，所以随着误差越传越远，梯度的偏
离也会越大。利用梯度校验在可以方便检验代码正确性的同时，还可以在梯度校
验的过程总发现，如果激活函数是Sigmoid函数，而网络有是深度网络，那么不经
过预训练的网络会出现梯度消失现象。
7.4 本章小结
本章中我们讨论了神经网络训练过程中一些会使用到的技巧，我们只介绍了
一些通用的技巧，更多的特殊技巧如dropout、maxout等我们并没有讨论，更多的
讨论可参考文献[44]和[45]。本章介绍的技巧中，降维自身就是一个很大的话题，
并不仅仅作为技巧而存在，它是机器学习的一个分支，我们只介绍了两种降维方
式，更多的降维方法如Isomap、局部线性嵌入、基于核的主成分分析等可参考文
献[46–48]。最后还需要说明一点，网络的设计者不应迷信这些技巧，它们只是起
到指导作用，具体是否可行要具体任务具体分析。
- 81 -
哈尔滨工业大学本科毕业设计（论文）
第 8 章 GPU计算
上世纪六十年代提出的摩尔定律到目前为止已经持续了半个多世纪，硅技术
似乎已经难以再有重大突破，摩尔定律在未来几年或将成为过去。然而当前计算
机的计算能力仍不足以满足人们的需求，并行技术的发展在一定程度上缓解了这
种压力，某种程度上而言，计算并行化可以看做是摩尔定律的一种延伸。
GPU（Graphic Processing Unit）又称“图形处理器”，是相对于CPU的一个概
念，其最初目的是满足计算机图形界面中人们对于实时、高清的三维图形的需
求。在图形开发中，由于图形渲染及变换等操作是带有可并行特征的，因此对
于GPU的设计者而言，他们更倾向于添加更多的核心而不是提高核心的运行效率，
通过多个核心以及线程技术，使得同一条指令可在每个元素上执行。此外，他们
还取消了CPU中的缓存与逻辑控制部件，因此GPU适用于计算密集的并行计算，
而CPU更适用于含有复杂流控的计算。
但是最初的GPU是为图形开发者而开发的平台，对于非图形开发者而言，
使用GPU进行通用计算并不是一件容易的事。为此，ATI公司（已被AMD收购）
于2005年提出的ATI Stream方案，NVIDIA公司在2007年推出的CUDA平台，都是
为了解决GPU通用计算问题而做出的努力。在GPU通用计算不断发展的同时，
新的规范 也被 不 断地 提出，Apple公 司在2008年 提 出OpenCL（Open Computing
Language）规范，微软提出的DirectCopmute规范，其目的都在于制定了一套API，
并在此基础上开发GPU通用计算软件。
在这些GPGPU（General Purpose GPU）方案中，由于CUDA为开发者提供了
一个类似于C的编程环境，使用者可以快速学习，所以受到了广泛的使用。
8.1 GPU体系结构
相 比 于CPU而 言， GPU由 于 其 设 计 原 则 就 是 针 对 密 集 运 算 的， 所 以
在 浮 点 运 算 上 占 着 先 天 优 势。 近 几 年CPU在 运 算 效 率 上 的 提 升 缓 慢， 与
此 同 时， GPU计 算 却 飞 速 发 展， 其 运 算 性 能 已 远 远 超 过CPU。 如 图 所 示
是Intel的CPU与NVIDIA的GPU在 各 个 型 号 上 每 秒 浮 点 运 算 量 的 对 比。 相 比
于CPU而言，GPU由于其设计原则就是针对密集运算的，所以在浮点运算上占着
先天优势。近几年CPU在运算效率上的提升缓慢，与此同时，GPU计算却飞速发
展，其运算性能已远远超过CPU。如图8-1所示是Intel的CPU与NVIDIA的GPU在各
- 82 -
哈尔滨工业大学本科毕业设计（论文）
个型号上每秒浮点运算量的对比
1
。
图 8-1 GPU 与CPU在每秒浮点运算量上的差异
由于GPU中取消了逻辑控制单元，相比于CPU其体系结构有着很大的不同。
典型的CPU结构带有三级缓存，数据由内存经过三层缓存后才进入到处理器核心，
这个结构如图所示。GPU同样带有缓存，这个缓存一般只有两级，与CPU不同的
是，CPU中只有一个处理器，而GPU中并没有处理器核心的概念，取而代之的是
流处理器簇（Streaming Muntiprocessor），在一个GPU中往往含有多个流处理器簇，
尽管它们与CPU处理器核心有着很大的差异，但某种程度上也可以看做是GPU的
核心，整个GPU的结构如图所示。
a) CPU结构 b) GPU结构
图 8-2 CPU与GPU结构差异
CPU为了实现多核技术，往往在一个芯片中集成多个CPU核心，例如在Intel
1
图片出自于NVIDIA的官方技术文档《CUDA C Programming Guide》
- 83 -
哈尔滨工业大学本科毕业设计（论文）
i7处 理 器 中 含 有4个CPU核 心， 多 核 心 使 得CPU可 以 并 行 执 行 计 算， 但 相 比
于GPU而言，CPU的并行粒度是非常大的。例如要将一个含有100个元素的向
量的每一个元素乘上一个常数2，那么对于4核的CPU，我们可以指派1号CPU执行
第1∼25个元素的操作，2号CPU执行第26∼50个元素的操作，但对于GPU而言，它
可以直接开辟100个线程，每个线程针对每个元素进行操作，这些线程是并行线程
而不是并发线程，因此GPU可以实现小粒度的并行。
GPU只所以能开辟大规模线程是因为一个GPU包含了一个流处理器簇阵列，
这个阵列由多个流处理器簇构成，例如费米架构的GPU的阵列大小为16。而每
个流处理器簇又包含了几十个到几百个的CUDA核心，例如，采用开普勒架构
的GPU每个流处理器簇包含48个CUDA核心，而采用费米架构的GPU每个流处理
器簇包含192个CUDA核心。这些核心并不类似于CPU的核心，CPU的每个核心只
能执行一个线程，而CUDA核心可以并行执行多个线程。
GPU的线程由线程网格管理，线程网格可以看做是一个二维网格，这个结构
如图8-3所示。在这个网格中，一个维度是线程块，另一个是线程束。每个GPU核
心最多可包含65536个线程块，每个线程块最多可包含512个线程束，这意味着我
们可以一次开辟最多大约3300万个线程，目前的费米架构已经实现每个线程块可
包含1024个线程束，因此它最多可开辟6600万个线程。但这只是说我们可以在代
码中开辟线程，并不意味着执行线程也是这个数量级。事实上，每个流处理器簇
可执行的线程数量是有限制的，这个数量级大约是一千左右。
图 8-3 线程网格
实际中在跑的线程数大约为几万，然而我们却可以在代码中开辟几千万的线
程，这得益于GPU对硬件的隐藏机制，类似于操作系统的虚拟地址，GPU会自动
地将这几千万的虚拟线程在几万实际线程中调度，而程序员不需要参与到这个过
- 84 -
哈尔滨工业大学本科毕业设计（论文）
程中，只需要在代码中开辟线程即可。这个机制使得硬件升级扩展变得简单，因
为虚拟的线程与实际调度的线程是分离的，GPU为我们自动调度，我们可以随意
的更换未来更多核心的GPU而不需要改动我们的代码。
为了更好地理解线程块与线程的概念，我们举一个GPU中实现两个向量相加
的例子，如代码8.1所示
代码 8.1 向量加法内核函数
1 g l o b a l vo id add ( i n t ∗c , i n t ∗a , i n t ∗b ) {
2 i n t t i d = b l o c k I d . x ;
3 c [ t i d ] = a [ t i d ] + b [ t i d ] ;
4 }
代码8.1中的的 kernel 代表这是一个在GPU中执行的代码，我们称其为内
核函数。由 kernel 标记的代码将由nvcc编译器编译，而没有这个标记的函数将
由C++的编译器编译
2
。第2行代表获取当前的线程号，这里我们假定线程号就是
线程块的编号，即默认每个线程块只有一个线程在运行。如果每个线程块有多个
个线程在执行，那么第2行代码应改为
i n t t i d = t h r e a d I d x . x + b l o c k I d . x + blockDim . x ;
观察图8-3，这实质上类似于二维索引空间转换为线性空间的代码。代码8.1中
的第3行代表每个线程执行一个操作，即将向量a中的第tid个元素与向量b中的
第tid个元素相加，并存储在向量c的第tid个元素中。这可以理解为，代码8.1会
做为一个副本分发给各个线程，各个线程拿到这段代码后，根据自己的线程ID
（即tid）执行向量a和向量b中的第tid的元素的操作。
8.2 CUDA
CUDA（Compute Unified Device Architecture）是NVIDIA公司在2007年推出的
高性能运算平台，它可以让GPU在执行常规的图形渲染的基础上额外地实现高性
能的通用并行计算。CUDA包含了CUDA指令集架构以及GPU内部的并行计算引
擎，通过利用GPU 的处理能力，可大幅提升计算性能。支持CUDA平台的GPU包
括NVIDIA Tesla 、NVIDIA Quadro 以及NVIDIA GeForce多个系列，其价格也涵盖
了高端到底端多个市场，使得CUDA能够满足从消费级到专业级等多个方面的
2
例如Windows操作系统下的msvc或Linux操作系统下的gcc
- 85 -
哈尔滨工业大学本科毕业设计（论文）
需求。目前为止，CUDA已经应用到图像与视频处理、计算生物学、流体力学
模拟、金融风险分析、地震分析等多个领域，全球五百强企业以安装700多个基
于CUDA的GPU集群，这些公司包括了能源领域的斯伦贝谢与雪佛龙以及银行业
的法国巴黎银行等。
在CUDA中， 程 序 员 需 要 手 工 将 数 据 从 内 存 中 迁 移 到GPU中，还 需 要 负
责GPU内存的回收，例如，为了执行两个向量的加法，其片段如代码8.2所示
代码 8.2 GPU 中向量加法的调用过程
1 i n t a [N] , b [N] , c [N ] ;
2 i n t ∗d e v a , ∗d e v b , ∗d e v c ;
3 / / i n i t a [N ] , b [N ] . . . . .
4 c u d a Ma ll oc ( ( v oi d ∗∗)& de v a , N∗ s i z e o f ( i n t ) ) ;
5 c u d a Ma ll oc ( ( v oi d ∗∗)& d e v b , N∗ s i z e o f ( i n t ) ) ;
6 c u d a Ma ll oc ( ( v oi d ∗∗)& de v c , N∗ s i z e o f ( i n t ) ) ;
7 cudaMemcpy ( d ev a , a , N∗ s i z e o f ( i n t ) , cudaMemcpyHostToDevice ) ;
8 cudaMemcpy ( dev b , b , N∗ s i z e o f ( i n t ) , cudaMemcpyHostToDevice ) ;
9 add <<<N, 1>>>( dev c , de v a , d e v a ) ;
10 cudaMemcpy ( c , de v c , N∗ s i z e o f ( i n t ) , cudaMemcpyDeviceToHost ) ;
11 c u d a F r e e ( d e v a ) ;
12 c u d a F r e e ( d ev b ) ;
13 c u d a F r e e ( d e v c ) ;
在代码8.2中，我们先在GPU中申请内存，即对应的4∼6行，随后在7∼8行中将
内存中的数据迁移到之前申请的GPU内存中。第9行执行代码8.1实现的加法内核
函数，在GPU中开辟N个线程块，每个线程块含有1个线程，GPU完成计算后，我
们在第10行将计算结果从GPU中迁移回内存，最后第11∼13行释放之前申请的内
存。释放内存是重要的，如果申请了内存不释放便会导致内存泄露，当内存消耗
完毕后程序崩溃。
我们不由感叹，为了执行一个简单的向量加法就要编写如此多的代码，我们
需要手工申请内存，手工将数据迁移到GPU中，手工调用内核函数，调用完毕后
需要手工将计算结果从GPU中迁移回来，最后还需要手工释放申请的内存。如果
用户不是专业的程序员，那么代码编写的过程十分困难。因此，在CUDA之上有
多个团队为机器学习研究人员开发了专门的第三方库，我们将会介绍几个常见的
包。
- 86 -
哈尔滨工业大学本科毕业设计（论文）
8.3 Cudamat
Cudamat是一个由多伦多大学开发的一套针对于Python的开源第三方库
[49]
，
它基于CUDA，在实现GPU高性能计算的同时保留了Python“语法优雅”的特性，
所以使用者可以很方便地在Python语法层次上调用矩阵运算库。开发Cudamat的
目的是为了方便机器学习建模，使科研人员从繁琐的CUDA编程中解放出来，
由 于GPU在 浮 点 并 行 运 算 上 巨 大 的 优 势，所 以 在 计 算 密 集 的 矩 阵 运 算 任 务
中Cudamat相对于numpy或MATLAB，其运算速度大约提升了50倍左右。
在Cudamat中，开发者已为我们重载了一些运算符，这使得矩阵的四则运算
运算以及面向元素的四则运算，以及矩阵的切片、转置等操作不再需要编写大量
的代码或调用对应的函数。此外，开发者还提供了一些常用的函数，例如面向元
素的exp()、log()、sqrt()、pow()，矩阵的乘法以及面向轴的求和、随机矩阵的生成
等。例如，为了实现一个logistic函数，只需要在Python中只书写代码8.3中的语句
代码 8.3 Cudamat中logistic的实现
d e f l o g i s t i c (A ) :
expTerm = cudamat . CUDAMatrix ( numpy . random . r a n d n (A . s ha p e ) )
cm . exp ( −A, t a r g e t =expTerm )
r e t u r n 1 / ( 1 + expTerm )
尽管Cudamat并没有将CUDA的所有功能都囊括其中，但在机器学习中常用的
功能基本都实现了，所有我们可以在不需要了解底层CUDA的前提下高效地建立
数学模型的代码，减轻了我们的工作量。
8.4 Gnumpy
在Python科 学 计 算 中， numpy与scipy两 个 第 三 方 包 充 当 着 重 要 角 色， 其
中numpy凭借其优美的语法实现以及高效地执行速率深受人们喜爱。在numpy中，
有着许多巧妙的设计，比如广播特性、切片、方便的元素存取、丰富的函数等。
其语法特性与MATLAB接近，几乎MATLAB上能实现的功能在numpy中都能找到
对应的实现，此外还加入一些MATLAB所不支持的功能，例如方便地嵌入C++代
码、方便地存储图像、网络IO等功能。尽管numpy语法简单，运行效率接近于C，
但由于其本质上还是基于CPU的运算，所以在大规模的计算中运行效率显得有些
难尽人意。
- 87 -
哈尔滨工业大学本科毕业设计（论文）
在Cudamat上编写代码要比直接地使用CUDA编写代码要方便得多，我们不
再需要了解底层，不再需要担心GPU的内存释放，不再需要编写复杂的内核函
数，然而，Cudamat代码要比numpy代码逊色不少，例如代码8.3中的exp函数需要
在参数列表中带上返回变量，而这个返回变量又必须要先声明，无法实现变量的
动态使用，所以Cudamat带着明显的C语言风格，这违背了Python关于“简单就是
美”的设计原则。鉴于以上原因，多伦多大学在cudamat的基础上开发了新一代的
开源第三方包—Gnumpy
[50]
。Gnumpy其计算本质是GPU计算，但其接口特性接近
于numpy。尽管Gnumpy是基于Cudamat的，但在Gnumpy中你将看不到Cudamat的
影子，开发者已经将其隐藏了，你看到的只有类似于numpy那样便捷的接口。例
如，同样是实现logistic函数，在Gnumpy中只需写成代码8.4中的形式
代码 8.4 Gnumpy中logistic的实现
d e f l o g i s t i c (A ) :
r e t u r n 1 / ( 1 + gnumpy . exp ( −A ) )
事实上，gnumpy已经为我们实现了logistic函数，因此我们只需要一条语句即
可完成该功能
A . l o g i s t i c ( )
使 用Gnumpy更 容 易 编 写 程 序， 代 码 相 对 于Cudamat而 言 更 简 短，也 更 容
易 阅 读与 调 试，对 于 拥 有numpy使用 经 验 的 开 发 者 而 言 可 以 很 容 易 地 上手。
尽 管Gnumpy是 基 于Cudamat的 基 础 上 进 行 的 二 次 开 发， 但 其 运 行 效 率 接 近
于Cudamat，因此使用者无需过于担心效率问题。
8.5 PyCUDA
无论是Gnumpy或是Cudamat都只提供了一些矩阵的基本操作，我们无法实
现一些这两个库没有的矩阵操作，例如二维离散卷积。如果我们因为内存管
理的原因不想直接写繁琐的CUDA C代码，那么PyCUDA是一个可以选择的库。
PyCUDA是由Andreas Klockner与Nicolas Pinto等人开发的一个Python第三方库
[51]
，
其目的在于允许我们在Python中内嵌CUDA C代码。在PyCUDA中，我们可以只
书写内 核函 数，而不写 内 存管理 的 代码。在程 序 第一次执 行时，Python会调
用CUDA的编译器将CUDA C的代码编译成动态链接文件，编译完成后可以直接
在Python中调用这个函数。例如，为了实现一个矩阵相乘的函数，我们的代码如
代码8.5所示
- 88 -
哈尔滨工业大学本科毕业设计（论文）
代码 8.5 Pycuda中实现向量相加
1 i mport py c u d a . d r i v e r a s GPU
2 from py c u d a . c o m p i l e r im port So u r ceModul e
3 d e f add (A, B , N ) :
4 code = S o u r c e Modul e ( ’ ’ ’
5 g l o b a l v o i d add ( i n t ∗c , i n t ∗a , i n t ∗b ) {
6 i n t t i d = b l o c k I d . x ;
7 c [ t i d ] = a [ t i d ] + b [ t i d ] ;
8 }
9 ’ ’ ’ )
10 a ddB yGP U = c o d e . g e t f u n c t i o n ( ” add ” )
11 C = numpy . z e r o s l i k e (A)
12 a ddB yGP U (GPU . Out (C ) , GPU . I n (A) , GPU . I n ( B ) ,
13 b l o c k =(N, 1 , 1 ) , g r i d = ( 1 , 1 ) )
14 r e t u r n C
代码8.5的第4∼9行通过字符串的形式嵌入CUDA C的内核函数，第10行试图去
获取名为“add”的内核函数，如果这行语句是第一次执行，并且在我们已经通
过字符串形式嵌入了“add”这个函数，那么Python就会调用nvcc编译器对代码进
行编译，并保存为动态链接文件，当下一次再试图获取这个内核函数时不需要再
编译一次而直接调用。第12行执行GPU中的计算，以A、B作为输入，C作为输出，
执行在N个线程块上。最后返回运算结果C。
PyCUDA使得我们的代码自由度变得更高，我们可以实现任何一个我们想要
的内核函数。但与此同时它也使得我们的代码变得复杂。天下没有免费的午餐，
选择一个自由度高的库或是选择一个代码简单的库完全取决于你的权衡。
8.6 Caffe
以上的几个Python第三方库都是一些机器学习中的通用库，这些库只提供
基础的功能，利用他们可以实现很多算法。如果一个科研人员没有太多程序
设计的经验，而又希望将他设计的神经网络在计算机上实现，那么Caffe是一个
选择。Caffe是由加州大学伯克利分校的Jia Yangqing 等人的领导下开发的一套
基于CUDA的深度学习工具箱
[52]
，其源代码由C++/CUDA实现，在此之上提供
了Python、MATLAB接口，并且可以通过命令行执行。在Caffe中，开发者已经编
- 89 -
哈尔滨工业大学本科毕业设计（论文）
写好各种各样的网络层的代码，如全连接层、卷积层等。使用者无需编写具体的
代码，Caffe让深度学习的研究人员从具体的代码中解放出来，我们只需要将自己
设计的网络模型写成配置文件即可。如代码8.6是一个神经网络的配置文件中的一
个片段
代码 8.6 神经网络配置文件片段
1 l a y e r s {
2 name : ” p o o l 1 ”
3 t y p e : POOLING
4 b o tto m : ” conv1 ”
5 t o p : ” p o o l 1 ”
6 p o o l i n g p a r a m {
7 p o o l : MAX
8 k e r n e l s i z e : 3
9 s t r i d e : 2
10 }
11 }
在代码8.6的配置文件片段中，定义了一个池化层。配置文件由两部分组成，
2∼5行为属性定义，6∼10行为参数定义。其中第2行定义了这层的名字，第3行定
义了层的类型，第4行定义了这层网络的前一层网络的名字，第5行定义了后一层
网络的名字（这里就是它自身）。第7行定义了这层池化层使用的是最大池采样，
第8行定义了卷积核的尺寸为3 × 3，第9行定义了卷积间隔为2。
8.7 本章小结
本章中，我们介绍了GPU计算，由于本文并不是一个GPU编程指南，因此我
们仅限于简单地介绍，更多关于CUDA C的编程指南可参考文献[53]和[54]。在本
章的后半阶段，我们介绍了几个基于CUDA开发的库，关于这几个库如何选取，
如果需要编写的代码只含有简单的矩阵操作，那么我们推荐使用Gnumpy库，如果
代码中含有一些很复杂的矩阵操作，而这些操作又是可并行的，那么我们推荐使
用PyCUDA。这两个库除了可以用在神经网络中外还可以用在别的机器学习算法
上，因为它们提供的功能是如此的基础以至于你可以任意组合出你希望的代码。
如果工作的内容只涉及神经网络，而又不想编写代码，那么我们推荐使用Caffe。
- 90 -
哈尔滨工业大学本科毕业设计（论文）
第 9 章 实验现象及讨论
我们在MNIST数据集上分别实现了深度置信网络与卷积神经网络，使用深度
置信网络训练得到的模型实现了98.72% 的识别正确率，使用卷积神经网络实现
了98.9%的识别正确率。我们在CIFAR-10数据集上实现一个卷积神经网络，实现
了62%的正确率，此外，通过Caffe测试了由xxx提出的网络构型的学习效果，并将
其与我们的网络学习效果进行对比。
9.1 数据集简介
MNIST与CIFAR-10是学术界两个重要的数据集，这两个数据集一般作为标准
数据集而存在，每当人们提出一种新的算法，都会用这两个数据集做验证，下面
我们将简单介绍这两个数据集。
9.1.1 MNIST
MNIST数据集是一个真实世界中采集的手写数字图像数据集
[55]
，它由NIST会
议收集并持有，读者可到MNIST主页免费获取该数据集。这个数据集一共含有4个
文件，分别存储训练数据、训练标签、测试数据、测试标签。文件以二进制文件
形式存储，不过我们可以很容易编写一段小代码将其转换成图像。训练集共含
有60000个样本，测试集含有10000个样本，这些样本收集自500位不同的人的手写
字体。
图 9-1 MNIST数据集部分数据样本
每个数据样本是28 × 28像素的灰度图像，由于引入了抗锯齿效果，所以图像
数值范围是0 ∼ 255而不是二值图像。图像已经经过预处理，因此图像会集中在中
- 91 -
哈尔滨工业大学本科毕业设计（论文）
心20 × 20的区域内，此外，图像的中心点与像素点的重心重合，所以如果要使用
模板匹配的方法（比如k近邻，SVM等）进行分类的话对图像再进行一些预处理
使得数字的几何中心与图像中心重合会改善你的算法性能。
如图9-1是MNIST数据集中的一小部分样本的展示，原始的数据应该是黑底白
字的，为了美观，我们将其颜色反转并加上周围的边框。
9.1.2 CIFAR-10
CIFAR是一个由Alex Krizhevsky, Vinod Nair以及Geoffrey Hinton收集的一个含
有8千万张图片的数据集
[56]
，这些图片并没有经过手工标注。而CIFAR-10是这个
数据集的一个子集，含有50000个训练样本和10000个测试样本，这些样本经过人
手工标注为10个类别，分别是飞机、小汽车、鸟、猫等
[57]
。读者可以从CIFAR-
10的官网免费获取这个数据集，它包含7个文件，其中有5个文件是训练集，每个
文件包含10000个训练样本，有1个文件存储测试集，包含10000个样本，这些样本
都被随机打散，所以不用担心类别的出现顺序会导致算法性能上的差异。剩余的
一个文件是标签值与类别名字的键值对。CIFAR-10为我们提供了三种存储形式，
分别对应Python、MATLAB与二进制形式的数据存储格式，读者可根据自己的语
言背景选取其中一种进行下载。
图 9-2 CIFAR-10数据集部分数据样本
每个数据样本都是大小为32 × 32的彩色图像，因此每张图像应包含三张32 ×
32大小的矩阵，分别代表R、G、B三个原色通道。如图9-2所示是这个数据集
的一部分样本，我们可以看到，这些图像更接近于真实生活中的图像，相比
- 92 -
哈尔滨工业大学本科毕业设计（论文）
于MNIST而言，每个类别个体的图像差异较大，而不像MNIST中每个类别的个体
差异较小，所以在CIFAR-10数据集中使用模板匹配的方法进行分类是几乎不可能
的。
9.2 深度置信网络在MNIST数据集上的性能
在MNIST数据集上，我们设计了一个7层神经网络，每层所含的节点分别
是784、621、982、600、410、569、10，最底层的节点数是根据原始数据输入维
度决定的，即28 × 28 = 784，最顶层的节点数是根据最终的类别决定的，即10个
类别。中间的隐含层节点我们随意选取，这些节点是如此的随意以至于源自我的
银行卡号。在深度置信网络中，对隐含节点并没有过多的要求，大致合理即可。
整个网络可以看做5个受限玻尔兹曼机叠加组成，分别是784∼621，621∼982，
···，410∼569，最后一层569∼10是softmax分类器。在整个网络的训练过程中，我
们先依次对其中的5个受限玻尔兹曼机做贪婪训练，即先训练784∼621的受限玻尔
兹曼机，训练完毕后将所有的样本（60000个）通过这个训练完毕的受限玻尔兹曼
机前向传播，得到60000个621维的数据样本，用这些维度变换后的样本训练下一
个，即621∼982的受限玻尔兹曼机，以此类推。最后的softmax分类器其预训练是
将其当做一个两层softmax网络进行预训练。
观察受限玻尔兹曼机的权值更新公式(4-43)、(4-44)以及(4-45)，为了方便大家
观察，我们将这三个公式再书写一次
∂ ln P(v)
∂w
i, j
≈ P(h
i
= 1|v
(0)
)v
(0)
j
− P(h
i
= 1|v
(k)
)v
(k)
j
(9-1)
∂ ln P(v)
∂b
vi
≈ v
(0)
j
− v
(k)
j
(9-2)
∂ ln P(v)
∂b
i
≈ P(h
i
= 1|v
(0)
) − P(h
i
= 1|v
(k)
) (9-3)
这三个公式背后隐藏着一层重构的含义，即对于一个两层的受限玻尔兹曼机，
在第一层的数据通过前向传播得到第二层的数据，第二层的数据反向注入得到第
一层的数据，数据经过这样一个迁移，相当于利用提取的特征重构原始样本，因
此在受限玻尔兹曼机的训练过程中，一个刻画其训练情况的方法是跟踪其重构误
差，如图9-3所示是某一层受限玻尔兹曼机的重构误差下降曲线。
- 93 -
哈尔滨工业大学本科毕业设计（论文）
图 9-3 受限玻尔兹曼机重构误差下降曲线
从图9-3中我们不难发现，训练的前10个周期重构误差迅速下降，随后的周期
下降速度缓慢，因此如果你的实验时间有限，那么可以只训练较少的周期即可，
但训练更多的周期会有助于获取更好的实验结果。需要提到的一点是，在受限玻
尔兹曼机的训练中，动量项是必须的，我们在实验中发现，不使用动量项时，在
训练的初始阶段重构误差无法下降。
我们还追踪了受限玻尔兹曼机对图像的具体重构，如图9-4所示是一些样本
在784∼621的受限玻尔兹曼机中的重构情况，原始样本与重构样本我们已在图中
标注。需要提醒的是，图9-4中的原始图像与图9-1中的原始图像不一致，这是因
为图9-1中的样本每个像素点取值是0 ∼ 255，而我们将这些像素点01化，所使用
的方法是，对每个像素点除以255得到一个[0,1]区间的小数p，以数值p为概率将其
置1，以1 − p为概率将其置0。另一种01化的方法是，直接保留这个小数而不将其
离散化。
图 9-4 受限玻尔兹曼机对数字的重构
最顶层的softmax分类器的训练也是贪婪的，即它只训练569∼10两层网络之间
的参数，在这里，训练周期我们不建议太长，一般训练5∼10个周期即可，否则在
- 94 -
哈尔滨工业大学本科毕业设计（论文）
随后的方向传播过程中，如果softmax预训练过久，则网络的输出误差较小，没有
误差就难以进行反向传播，全局微调容易失败，这会导致网络陷入局部最优解，
这个局部最优由最顶层的softmax决定而不是整个网络决定。
当整个网络预训练完毕后，我们执行全局的反向传播算法对参数进行微调，
这个过程与传统的神经网络相同，我们不进行过多的叙述，如图9-5所示是整个网
络进行反向传播时的误差下降曲线
图 9-5 深度置信网络误差下降曲线
细心的读者会发现，图9-5的下降曲线表明最终这个网络并没有收敛到我们
号称的正确率98.72%，确实如此，因为我们在数据迁移时遗失了一部分的数据，
图9-5中的数据是前期研究工作中没有遗失的数据，因此这并不是最终的误差下降
曲线。但是我们的实验是可重现的，只需按照我们的结构便可再现98.72% 的正确
率，由于我们的时间有限，并没有将这个实验重新做一遍，感兴趣的读者可以尝
试。
网络训练完毕后，我们选取了一部分网络识别错误的数字，将其展示在
图9-6中，每个样本下边的黑色数字代表测试集给定的标签，而红色数字代表网络
的预测标签。我们可以发现，这些错误的样本中，有一部分自身就带有二义性，
人也难以区分究竟是哪个数字，而有一部分样本人可以很容易识别，网络却识别
错误，还有一部分样本数据本来就是错误的，根本无法识别它是哪个数字，这时
候我们不能舍弃机器也能将其识别出来。
在整个网络的训练中，我们使用了动量项、权衰减技术，而没有没有使用降
维技术，因为数据维度并不是特别高，计算机的处理能力足以应付。如果原始数
据的维度非常高，比如几百万维，那么就需要采用一些降维技术将原始数据进行
压缩。
- 95 -
哈尔滨工业大学本科毕业设计（论文）
图 9-6 被网络误分类的样本
深度置信网络在一定程度上仍然带有模板匹配的气息，因为我们如果只使
用2000个样本作为训练集而不是全部的60000个样本，网络也能实现90多的正确
率，后面中的实验中我们会看到，这种策略在卷积神经网络中是行不通的。
9.3 卷积神经网络在MNIST数据集上的性能
在MNIST数据集，我们设计了一个6层卷积网络，其网络构型描述如下
• 1张28 × 28的原始图像
• 卷积原始图像得到6张24 × 24特征图
• 对6张特征图进行采样得到6张12 × 12特征图
• 对6张特征图进行卷积得到12张8 × 8特征图
• 对12张特征图进行采样得到12张4 × 4特征图
• 此时12张4 × 4特征图无法再进行卷积，将其展开得到192个节点
• 192个节点与10个输出节点做全连接网络，与传统神经网络一样
其中，激活函数我们选取的是sigmoid函数，当然这个函数也可以换成ReLU函
数，全连接网络我们采用平方误差作为准则，而不是深度置信网络中的softmax分
类器。在这个网络中，我们不采用预训练而是直接进行全局的反向传播。以上的
网络构型的选取方案都是随意的，并没有说一定要采用这个方案。
实 验 获 取 的 训 练 误 差 及 测 试 误 差 曲 线 如 图9-7所 示，训 练 完 毕 后，我 们
在MNIST上取得了98.9%的正确率。我们可以看到，在网络训练的前20个周期，
训练误差与测试误差迅速下降，随后的周期中误差缓慢下降，到了后期，收敛十
分缓慢，但依然会有下降的趋势。有意思的是，对网络训练一个很长的周期并不
- 96 -
哈尔滨工业大学本科毕业设计（论文）
会产生明显的过学习现象，所以如果你需要实现一个高识别率的网络，那么你可
以放心地等待一段很长的的时间。
值得注意的是，误差下降过程带有明显的波动性，在深度置信网络的训练
过程中，一般到了训练的后期，识别率不会有太大的波动，比如，深度置信网
络在到达98.70%的正确率后，其波动范围就在98.70%附近波动，可能是98.73%、
98.74%。然而，在卷积网络中，到达98.70%后，它可能一下子跌到98.40%，然后
又升到98.80%，这种较大范围的波动，应该不是随机梯度造成的，因为深度置信
网络中我们采取随机梯度更新时也没有这么大的波动，我们推测这是因为卷积网
络代表着一种非常强的惩罚（强迫权值共享），惩罚过大导致波动变大。
图 9-7 卷积神经网络训练误差及测试误差
在实验中，我们并没有采用权衰减，因为我们发现使用权衰减后网络的性能
变差。此外，我们发现当改变网络中的一些参数，比如特征图的张数，学习率时，
对网络的收敛影响较大，但对最终结果并没有太大影响。卷积网络对样本的需求
量非常大，实验中，我们选取2000个样本作为训练集对网络进行训练，网络完全
不会收敛，这与深度置信网络是不一样的，只有我们将所有的60000个样本作为
训练集对网络进行训练时，网络才开始收敛。我们估计这是因为卷积网络的权值
共享导致它只有通过大量的样本才能学习特征，这与模板匹配方法有着很大的区
别。
网络训练完毕后，我们对测试集中的一部分数据进行观察，第一层卷积层提
取出的特征如图9-8 a)所示。我们分别选取了0 ∼ 9一共10个样本，每一行代表一
个样本。其中，每一行的第一张是原始的28 × 28图像，随后六张是卷积出来的六
张24 × 24大小的特征图。观察图9-8 a)，我们可以发现一些有意思的现象。例如，
原始图像是黑底白字的，而有一些特征图反转成为白底黑字，又比如，第六张特
征图是对图像进行边界检测，为了验证我们这个想法，我们随机选取了“4”这个
- 97 -
哈尔滨工业大学本科毕业设计（论文）
数字的几个样本进行特征抽取，其结果如图9-8 b) 显示，通过观察，我们不难发
现，对于不同的写法，其提取到的特征都是近似的，它会检测“4”的左边竖线的
上方一点以及对下来的一个折线，右边竖线的上方一点以及下方的一点。另一个
有意思的现象是，第三张特征图看起来是一个3D图像，想象图像的左上角有一束
阳光洒下，当我们伸出右手，掌心贴着当前的纸张页面，大拇指朝纸张左方，握
拳，数字经过我们四个手指的方向旋转过一定角度后，那么阳光洒下的阴影如同
第三张特征图所示。这个现象在第五张特征图中也出现了，只是第五张特征图的
阳光处于左侧而不是左上角。同样伸出我们的右手，掌心贴着当前的纸张页面，
大拇指朝纸张下方，握拳，我们可以看到数字经过我们四个手指的方向旋转过一
定角度后，阳光洒下的投影正如第五张特征图所示。
a) 针对0-9不同数字提取到的特征图
像
b) 针对数字“4”提取到的特征
图 9-8 第一层卷积层抽取得到的特征图
9.4 卷积神经网络在CIFAR-10数据集上的性能
相比于MNIST数据集，CIFAR-10数据集的识别更为困难。由于计算资源的限
制，我们只在CIFAR-10上设计了一个较小的卷积网络，与MNIST手写数字的卷积
网络构型类似，在CIFAR-10数据集上，我们同样设计了一个4层卷积网络，其网
- 98 -
哈尔滨工业大学本科毕业设计（论文）
络构型描述如下
• 3张32 × 32的原始图像
• 卷积原始图像得到9张28 × 28特征图
• 对9张特征图进行采样得到9张14 × 14特征图
• 尽管9张5 × 5特征图仍然可以被卷积，但我们依然将其展开为1764个节点
• 1764个节点与10个输出节点做全连接网络，与传统神经网络一样
网络的属性与MNIST实验中的相同，激活函数我们依然选取sigmoid函数，全
连接网络依然采用平方误差作为准则，对网络进行训练得到训练集误差下降如
图9-9 a)所示，测试集误差量下降如图9-9 b)所示。需要注意的是，看起来在图9-9
a)与图9-9 b)中误差下降速度非常快，对比与图9-7，其斜率更大，然而这是一个假
象，因为我们对纵轴进行了尺度缩放，事实上在CIFAR中误差下降的非常慢，而
且在训练集与测试集中仍然后很大的误差可以下降。
a) 训练误差下降曲线 b) 测试误差下降曲线
图 9-9 CIFAR的训练误差与测试误差
因为CIFAR-10数据集的复杂性，本应该建立一个庞大的网络进行训练，但由
于我们的计算资源有限，时间紧迫，所以无法实现一个更大的卷积网络，此外，
对网络的训练我们也仅仅训练了400个周期左右，因此，整个网络训练完毕后我们
只得到62%的识别正确率。
如图9-10所示是一部分被网络正确识别的样本，其中每一行代表一个类别，
图中总共包含了10个类别100个样本。观察这些样本我们会发现，网络能识别的图
像对位移、旋转等性质具有不敏感性。例如，在飞机这个类别中，网络可以识别
头部向左、向右等多个角度的飞机，还可以识别俯仰角不同的图片，由于这些图
片不具备模板性，所以卷积网络基本没有了模板匹配的缺点。
- 99 -
哈尔滨工业大学本科毕业设计（论文）
图 9-10 被网络正确识别的CIFAR-10部分样本
我们跟踪了网络无法识别的样本，将其一部分绘制如图9-11所示。图中每个
样本下方的黑色数字代表由训练集提供的标签值，而红色数字代表网络的输出标
签值，标签值于类别名字的键值对可参照图9-1。我们发现，在一些样本中，网络
会将大卡车错误地识别成小汽车或将小汽车错误地识别成大卡车，这似乎可以原
谅，但有一些图像的错误识别是我们无法原谅的，例如将马识别成大卡车。这些
错误的样本中很多样本人是可识别的，而机器不可识别，我们推测这是因为我们
的网络设计得不够庞大，训练周期也步长，导致网络无法进行更好的特征提取，
从而影响最终的识别效果。
图 9-11 被网络错误识别的CIFAR-10部分样本
- 100 -
哈尔滨工业大学本科毕业设计（论文）
为了描述网 络的特 征 提取 性 能，如 同在MNIST上 卷 积网 络 的工 作，我 们
同样将第一层卷积层提取到的特征绘制如图9-12所示。我们选取了“飞机”类
别下的9个样本，每一行代表一个样本。其中，每一行的前三张黑白图像是原
始32 × 32大小的RGB通道，这三张图像合成第四张32 × 32彩色图像。随后的九张
是第一层卷积层提取到的九张28 × 28大小的特征图。对比这些原始数据与特征图，
我们发现，原始数据中图像是含有冗余的，大部分的特征图过滤掉这些冗余信
息，将飞机的边界提取出来形成特征图。这些特征图中，有一些特征例如第2张，
第8张并没有提取到一些人可理解的特征，我们猜测随着训练周期的增加，这些特
征将会逐渐显露出来，由于时间有限，我们并没有验证我们的猜想。
图 9-12 针对“飞机”类别提取的特征
这些特征图应该可以通过选取某几张组成彩色的特征图，但我们并不知道选
取哪几张合适，所以我们并没有做这一步工作。此外，这些特征图表明，在他们
之上应该再添加一些卷积层对特征继续提取，而不是我们设计的全连接网络，由
于我们的计算资源十分匮乏，所以我们也没有进一步展开这项工作。
9.5 使用Caffe实现的CIFAR-10数据集训练
目前学术界认为CIFAR-10数据集已被解决，因为最好的识别效果由xxx实
现，正确率为91%。另一识别率较高的网络由Alex Krizhevsky等人实现，其识别率
为89%，这个网络稍微有点复杂所以我们不会在本文中提及，更多的讨论可阅读
- 101 -
哈尔滨工业大学本科毕业设计（论文）
其论文[41]。在Caffe中的卷积网络构型采取的是Alex Krizhevsky的方案，为了实现
对比，我们使用Caffe验证了Alex Krizhevsky等人的网络构型在CIFAR-10数据集上
的训练效果，其训练误差与测试误差曲线如图9-13所示
a) 训练误差下降曲线 b) 测试误差下降曲线
图 9-13 使用Ca ffe训练模型得到的误差
由于Caffe的源代码是每100个周期对训练误差做一次测试，每500个周期对测
试误差做一次测试，所以图9-13中的曲线看起来并不光滑。此外我们可以看到，
训练误差有很大的波动，这是因为Alex Krizhevsky设计的网络为了避免过学习使
用了dropout技巧，这个技巧会对训练集产生一个很大的惩罚，从而导致训练误差
出现波动，然而这个技巧并不会对测试误差产生较大的波动。
Alex Krizhevsky设计的网络规模远远超过我们设计的网络，例如他们的网络
仅特征图的数量就达几百张，而我们的网络中只有9张。从图9-13中的测试误差我
们可以看到，经过5000个周期的训练后，这个网络实现了75.1%的正确识别率，如
果让网络继续训练，那么它将会收敛到文章[41]中号称的89%正确率。
对于比Alex Krizhevsky设计的网络，我们的网络实现的62%正确率看起来低
得可怜，但情况似乎并没有这么糟糕，我们的网络只训练了大约300个周期后实
现62%正确率，而Alex Krizhevsky的网络训练了5000个周期实现75.1%的正确率，
如果我们横向对比，Alex Krizhevsky设计的网络在训练500个周期时得到的正确率
为54.21%，这个效果低于我们的网络效果。当然，这其中并不能排除一些因素的
印象，比如我们的实验中通过对数据镜像处理将训练集规模扩大为两倍，此外，
我们也没有引入避免过学习的惩罚，这种惩罚在一定程度上会降低收敛速度，但
会提高最终的收敛性能。尽管如此，我们乐观地估计，如果将我们的网络规模扩
大，并且延长训练周期，那么应该能实现80%多的识别正确率。
在CIFAR-10这个任务中，我们可以看到卷积网络的威力所在，这个任务使用
- 102 -
哈尔滨工业大学本科毕业设计（论文）
传统的全连接神经网络大约只能实现40%左右的正确率，而使用模板匹配的方法
基本是不可行的。卷积网络在图像识别中特征自学习的性能使得它远远超过机器
学习中别的算法，目前主流的图像识别技术基本由卷积网络实现。
9.6 本章小结
本章讨论了我们在MNIST数据集与CIFAR-10数据集上获得的实验现象与结果
讨论。对于MNIST这种数据特征已经被很好地预处理，没有过多噪声，也没有太
多的旋转、伸缩、位移等变化的图像，那么采用采用全连接神经网络或采用机器
学习中很多别的方法也能实现很好的识别效果。但对于CIFAR-10这种源自于真实
生活中的图片，特征并没有经过预处理，并且每个类别的个体都带有很大的差异
性，那么使用全连接网络并不是一个较好的效果。有些时候，卷积网络也被看做
一种滤波，正如我们试验中看到的特征图，它会将原始图像中的特征自动过滤出
来供给下一层网络，并且这个特征提取过程对位移等变换是不敏感的。我们曾经
提过，深度学习也称特征学习，即神经网络对数据进行逐层的特征提取，这些特
征必须是能描述原始图像的特征，根据这些特征能够反向还原出数据的原始大致
面貌。无论是那种方法，对数据的需求量都很大，并且任务越复杂，需求越大，
小样本的数据并不适合使用深度学习处理，因为小样本机器无法探索出那些特征
才是对分类有帮助的。对于小样本数据，应该在模型中加入人的知识，而不是奢
望机器自动学习这些知识，对于大的数据，如果能往模型中添加人的知识
1
，那么
也能很大程度地提高机器的学习性能，毕竟人工智能业内有一句话：有多少人工，
就有多少智能。
1
例如卷积网络中我们就是这样干的
- 103 -
哈尔滨工业大学本科毕业设计（论文）
结 论
本文的主要目的在于介绍深度学习在图像识别中的应用，文中有两条主线贯
穿全文。我们先从控制论与机器学习的关系说起，随后引入了第一个刻画数据分
布的模型即受限玻尔兹曼机，为了介绍受限玻尔兹曼机的训练方法，我们讨论了
马尔可夫链蒙特卡罗方法。在受限玻尔兹曼机的基础上，我们讨论了如何利用它
们堆叠得到深度置信网络，并介绍了反向传播算法。至此我们完成了深度学习的
第一条主线即深度置信网络的讨论。随后我们展开了第二条主线即卷积神经网络
的讨论，并在其后介绍了神经网络的设计技巧与GPU高性能计算。
最 后， 我 们 通 过 三 个 实 验 测 试 了 深 度 学 习 在 图 像 识 别 中 的 识 别 效 果。
在MNIST数据集中，使用深度置信网络实现了98.7%的识别正确率，使用卷积
神经网络实现了98.9%的识别正确率。在CIFAR-10数据集中，我们使用卷积神经
网络实现了62%的识别正确率，尽管这个结果与当前世界顶尖的结果91%的正确
率相差较远，但通过与Caffe训练的卷积网络做对比，我们乐观地认为我们的网络
仍有很大的收敛空间。
深度学习作为一种特征学习，较传统模式识别方法有本质化的改变，尤其是
在图像识别领域。这套方法应当值得研究人员关注。
- 104 -
哈尔滨工业大学本科毕业设计（论文）
参考文献
[1] Bishop C M, et al. Pattern recognition and machine learning[M]. Vol. 1.[S.l.]:
springer New York, 2006.
[2] Vladimir N. Vapnik 原著, 张学工 译. 统计机器学习理论的本质[M]. 北京: 清华
大学出版社, 2000.
[3] Duda R O, Hart P E, Stork D G. Pattern classification[M].[S.l.]: John Wiley &
Sons,, 1999.
[4] Bengio Y. Learning deep architectures for AI[J]. Foundations and trends
R
⃝ in Ma-
chine Learning, 2009, 2(1):1–127.
[5] Hinton G E. To recognize shapes, first learn to generate images[J]. Progress in brain
research, 2007, 165:535–547.
[6] Hinton G, Osindero S, Teh Y W. A fast learning algorithm for deep belief nets[J].
Neural computation, 2006, 18(7):1527–1554.
[7] Hinton G. A practical guide to training restricted Boltzmann machines[J]. Momen-
tum, 2010, 9(1):926.
[8] Erhan D, Manzagol P A, Bengio Y, et al. The di fficulty of training deep archi-
tectures and the effect of unsupervised pre-training[C]//International Conference on
Artificial Intelligence and Statistics. .[S.l.]: [s.n.] , 2009:153–160.
[9] Bengio Y, Lamblin P, Popovici D, et al. Greedy layer-wise training of deep network-
s[J]. Advances in neural information processing systems, 2007, 19:153.
[10] Poultney C, Chopra S, Cun Y L, et al. Efficient learning of sparse representations
with an energy-based model[C]//Advances in neural information processing system-
s. .[S.l.]: [s.n.] , 2006:1137–1144.
[11] Hinton G E, Salakhutdinov R R. Reducing the dimensionality of data with neural
networks[J]. Science, 2006, 313(5786):504–507.
[12] LeCun Y, Bengio Y, Hinton G. Deep learning[J]. Nature, 2015, 521(7553):436–444.
[13] 冯·诺伊曼 原著, 甘子玉 译. 计算机与人脑[M]. 北京: 北京大学出版社, 2010.
[14] Schmidhuber J. Deep Learning in Neural Networks: An Overview[J]. arXiv preprint
arXiv:1404.7828, 2014.
[15] Williams D R G H R, Hinton G. Learning representations by back-propagating
errors[J]. Nature, 1986:323–533.
- 105 -
哈尔滨工业大学本科毕业设计（论文）
[16] Ma-ckay, D.J.C. 原著, 肖明波 等译. 信息论、推理与学习算法[M]. 北京: 高等
教育出版社, 2006.
[17] Ackley D H, Hinton G E, Sejnowski T J. A learning algorithm for boltzmann ma-
chines[J]. Cognitive science, 1985, 9(1):147–169.
[18] LeCun Y, Boser B, Denker J S, et al. Backpropagation applied to handwritten zip
code recognition[J]. Neural computation, 1989, 1(4):541–551.
[19] LeCun Y, Bottou L, Bengio Y, et al. Gradient-based learning applied to document
recognition[J]. Proceedings of the IEEE, 1998, 86(11):2278–2324.
[20] Arel I, Rose D C, Karnowski T P. Deep machine learning-a new frontier in artificial
intelligence research [research frontier][J]. Computational Intelligence Magazine,
IEEE, 2010, 5(4):13–18.
[21] Salakhutdinov R. Learning deep generative models[D].[S.l.]: University of Toronto,
2009.
[22] 余凯, 贾磊, 陈雨强, et al. 深度学习的昨天, 今天和明天[J]. 计算机研究与发展,
2013, 50(9):1799–1804.
[23] He K, Zhang X, Ren S, et al. Delving Deep into Rectifiers: Surpassing Human-Level
Performance on ImageNet Classification[J]. arXiv preprint arXiv:1502.01852, 2015.
[24] 维纳 原著, 陈步 译. 人有人的用处：控制论与社会[M]. 北京: 北京大学出版
社, 2010.
[25] Tom M.Mitchell 原著, 曾华军 等译. 机器学习[M]. 北京: 机械工业出版社, 2003.
[26] LeCun Y, Chopra S, Hadsell R, et al. A tutorial on energy-based learning[J]. Pre-
dicting structured data, 2006, 1:0.
[27] Andrieu C, De Freitas N, Doucet A, et al. An introduction to MCMC for machine
learning[J]. Machine learning, 2003, 50(1-2):5–43.
[28] Carreira-Perpinan M A, Hinton G E. On contrastive divergence learning[C]//. .[S.l.]:
[s.n.] , 2005.
[29] Tieleman T. Training restricted Boltzmann machines using approximations to the
likelihood gradient[C]//Proceedings of the 25th international conference on Machine
learning. .[S.l.]: [s.n.] , 2008:1064–1071.
[30] Barron A R. Universal approximation bounds for superpositions of a sigmoidal
function[J]. Information Theory, IEEE Transactions on, 1993, 39(3):930–945.
- 106 -
哈尔滨工业大学本科毕业设计（论文）
[31] Glorot X, Bordes A, Bengio Y. Deep sparse rectifier neural network-
s[C]//International Conference on Artificial Intelligence and Statistics. .[S.l.]: [s.n.]
, 2011:315–323.
[32] Boser B E, Guyon I M, Vapnik V N. A training algorithm for optimal margin
classifiers[C]//Proceedings of the fifth annual workshop on Computational learning
theory. .[S.l.]: [s.n.] , 1992:144–152.
[33] Cortes C, Vapnik V. Support-vector networks[J]. Machine learning, 1995,
20(3):273–297.
[34] Erhan D, Bengio Y, Courville A, et al. Why does unsupervised pre-training help
deep learning?[J]. The Journal of Machine Learning Research, 2010, 11:625–660.
[35] Hinton G E. Learning multiple layers of representation[J]. Trends in cognitive
sciences, 2007, 11(10):428–434.
[36] Abdel-Hamid O, Mohamed A r, Jiang H, et al. Applying convolutional neural
networks concepts to hybrid NN-HMM model for speech recognition[C]//Acoustics,
Speech and Signal Processing (ICASSP), 2012 IEEE International Conference on.
.[S.l.]: [s.n.] , 2012:4277–4280.
[37] Sukittanon S, Surendran A C, Platt J C, et al. Convolutional networks for speech
detection.[C]//. .[S.l.]: [s.n.] .
[38] LeCun Y, Bengio Y. Convolutional networks for images, speech, and time series[J].
The handbook of brain theory and neural networks, 1995, 3361(10).
[39] Bouvrie J. Notes on convolutional neural networks[J]. 2006.
[40] Lee H, Grosse R, Ranganath R, et al. Convolutional deep belief networks for
scalable unsupervised learning of hierarchical representations[C]//Proceedings of
the 26th Annual International Conference on Machine Learning. .[S.l.]: [s.n.] ,
2009:609–616.
[41] Krizhevsky A, Sutskever I, Hinton G E. Imagenet classification with deep con-
volutional neural networks[C]//Advances in neural information processing systems.
.[S.l.]: [s.n.] , 2012:1097–1105.
[42] Kruskal J B. Multidimensional scaling by optimizing goodness of fit to a nonmetric
hypothesis[J]. Psychometrika, 1964, 29(1):1–27.
[43] Simard P Y, Steinkraus D, Platt J C. Best p ractices for convolutional neural networks
applied to visual document analysis[C]//null. .[S.l.]: [s.n.] , 2003:958.
- 107 -
哈尔滨工业大学本科毕业设计（论文）
[44] Baldi P, Sadowski P J. Understanding Dropout[C] //Advances in Neural Information
Processing Systems. .[S.l.]: [s.n.] , 2013:2814–2822.
[45] Goodfellow I J, Warde-Farley D, Mirza M, et al. Maxout networks[J]. arXiv preprint
arXiv:1302.4389, 2013.
[46] Tenenbaum J B, De Silva V, Langford J C. A global geometric framework for non-
linear dimensionality reduction[J]. Science, 2000, 290(5500):2319–2323.
[47] Roweis S T, Saul L K. Nonlinear dimensionality reduction by locally linear embed-
ding[J]. Science, 2000, 290(5500):2323–2326.
[48] Sch
¨
olkopf B, Mika S, Smola A, et al. Kernel PCA pattern reconstruction via
approximate pre-images[M]//ICANN 98.[S.l.]: Springer, 1998:147–152.
[49] Mnih V. Cudamat: a CUDA-based matrix class for python[J]. Department of Com-
puter Science, University of Toronto, Tech. Rep. UTML TR, 2009, 4.
[50] Tieleman T. Gnumpy: an easy way to use GPU boards in Python[J]. Department of
Computer Science, University of Toronto, 2010.
[51] Kl
¨
ockner A, Pinto N, Lee Y, et al. PyCUDA and PyOpenCL: A Scripting-Based
Approach to GPU Run-Time Code Generation[J]. Parallel Computing, 2012,
38(3):157–174.
[52] Jia Y, Shelhamer E, Donahue J, et al. Caffe: Convolutional Architecture for Fast
Feature Embedding[J]. arXiv preprint arXiv:1408.5093, 2014.
[53] Shane Cook 原著, 苏统华 等译. CUDA并行程序设计GPU编程指南[M]. 北京:
机械工业出版社, 2014.
[54] Jason Sanders, Edward Kandrot 原著, 聂雪军 等译. GPU高性能编程CUDA实
战[M]. 北京: 机械工业出版社, 2011.
[55] LeCun Y, Cortes C. MNIST handwritten digit database[J]. AT&T Labs [Online].
Available: http://yann. lecun. com/exdb/mnist, 2010.
[56] Krizhevsky A, Hinton G. Learning multiple layers of features from tiny images[J].
2009.
[57] Krizhevsky A, Hinton G. CIFAR-10 database[J]. Canadian Instistute for Advanced
Resserch [Online]. Available: http://www.cs.toronto.edu/ kriz/cifar.html, 2009.
- 108 -
哈尔滨工业大学本科毕业设计（论文）
哈尔滨工业大学本科毕业设计（论文）原创性声明
本人郑重声明： 在哈尔滨工业大学攻读学士学位期间，所提交的毕业设计
（论文）《深度学习在图像识别中的应用》，是本人在导师指导下独立进行研究工
作所取得的成果。对本文的研究工作做出重要贡献的个人和集体，均已在文中以
明确方式注明，其它未注明部分不包含他人已发表或撰写过的研究成果，不存在
购买、由他人代写、剽窃和伪造数据等作假行为。
本人愿为此声明承担法律责任。
作者签名： 日期： 年 月 日
- 109 -
哈尔滨工业大学本科毕业设计（论文）
致 谢
首先我需要感谢我的导师杨旭东先生。在这个课题开始之前我和杨老师对深
度学习都没有过多的接触，整个课题研究过程中我们多次进行讨论，共同学习。
杨老师对我十分信任，并不过多地干预我的工作内容，让我随兴趣展开研究，只
在关键地方为我指导，并且深信我的实验能成功。感谢杨老师对我的信任与支持，
让我有足够多的时间与信心来深入研究这个课题，特此致敬。
其次我需要感谢计算机学院硬件实验室的陈慧鹏先生。陈老师是我大学四年
的思想启蒙教师，他教会了我如何思考以及人生的意义，他有趣的《计算机组成
原理》课程最终使我走上计算机的道路，如果没有遇到陈老师，或许大学四年我
都找不到自己兴趣所在。陈老师为我提供了舒适的实验室条件与计算资源，在这
个实验室中我完成了论文的大部分研究工作，再次感谢陈老师的支持与帮助。
特别要感谢计算机学院模式识别研究中心的刘家锋先生。我曾旁听过刘老师
的《模式识别》课程，刘老师课堂上严谨的授课方式，信手拈来的公式推导使我
折服。承蒙刘老师不嫌弃我学识疏浅，在课后仍为我解惑释疑，在百忙之中抽出
时间帮我审阅论文，我的感激之情难以言表。
我还需要感谢计算机学院自然计算实验室的刘扬先生，刘老师的《机器学
习》课程深入浅出，生动地将枯燥复杂的数学语言形象化，在年初我实验遇到瓶
颈时给予我鼓励与建设性意见，并带我领略了当前机器学习的研究进展与热点，
十分感谢他的无私帮助。
最后我还需要感谢在实验室遇到的几位不知名的老师，其中一位老师为我解
答了机器学习与模式识别两者间的差异性，这个问题长期困扰着我。另一位与我
一同讨论的老师，我俩的讨论使我对深度学习中的一些模棱两可的概念清晰化。
还有多位给予我鼓励的老师，遗憾的是我并不知道他们的姓名，但我仍需要对他
们表示崇高的敬意。
我的文字表达能力不强，大家从我的论文也可以感受到，文字不足以表达我
的感激之情，没有以上多位老师以及我身边的同学给予我的支持，这篇论文将无
法完成。最后的最后，让我再一次将我的敬意献给以上的多位老师以及同学。
- 110 -
哈尔滨工业大学本科毕业设计（论文）
附录 A 深度置信网络源代码
本附录中我们提供深度置信网络在MNIST中的实现源代码。在这个实验中，
我们使用Gnumpy库为程序加速，使得原本需要执行大约需要一个月的训练只需要
在1天之内完成。出于页面限制，我们对代码进行了一些格式调整，这使得代码格
式看起来并不规范。此外，为了页面简洁，我们删除了一部分无用代码，由于在
我写下这些代码的时候，只有我和上帝知道这些代码究竟干了什么而现在只剩下
上帝知道了，所以我不确定是否删掉了一些看起来无用但有用的代码。因此这些
代码不一定能执行成功，但是读者可按照这些代码的大体思路自行根据自身的语
言背景重新实现一遍。
这几个文件中，Main.py是整个程序的主入口。MNIST.py是一个工具文件，主
要提供获取数据集以及绘制图像功能，需要注意的是，对于MNIST，我们已经将
数据的前几个字节中的魔数去掉了，所以如果你的数据是直接从MNIST官网上获
取的话，在读取数据的时候需要跳过几个字节，具体的参考官方文档。RBM.py是
受限玻尔兹曼机的类文件。softmax.py是softmax分类器的类，它继承于RBM这个
类，并且对training()方法进行重写，从而实现多态性。DBNs.py是深度置信网络的
类文件，它由多个RBM与一个softmax组成，可对其执行分层的预训练与全局的权
值微调。
代码 A.1 Main.py
1 from numpy import ∗
2 from DBNs impo rt ∗
3 i mport numpy a s np
4
5 nodeNum = [ 7 8 4 , 62 1 , 98 2 , 6 0 0 , 41 0 , 5 6 9 , 1 0 ]
6 dbn = DBNs( nodeNum )
7 # dbn = DBNs ( nodeNum , l o a d P a r a m e t e r =Tr ue )
8 dbn . p r e T r a i n i n g ( )
9 # dbn . r e c o n s t r u c t ( )
10 dbn . r e c o g n i z e ( )
- 111 -
代码 A.2 MNIST.py
1 from s t r u c t imp ort ∗
2 from numpy import ∗
3 from s c i p y i mport mi s c
4 i mport Image
5
6 d e f g e t D a t a ( ) :
7 t r a i n i n g F i l e = open ( r ’ t r a i n i n g D a t a ’ , ’ r b ’ )
8 t r a i n i n g D a t a = f r o m f i l e ( t r a i n i n g F i l e , d t y p e = u i n t 8 )
9 . r e s h a p e ( −1 , 7 8 4)
10 t r a i n i n g F i l e . c l o s e ( )
11
12 t r a i n i n g L a b e l F i l e = open ( r ’ t r a i n i n g L a b e l ’ , ’ r b ’ )
13 t r a i n i n g L a b e l = f r o m f i l e ( t r a i n i n g L a b e l F i l e , d t y p e= u i n t 8 )
14 t r a i n i n g L a b e l F i l e . c l o s e ( )
15
16 t e s t I m a g e F i l e = open ( r ’ t e s t D a t a ’ , ’ r b ’ )
17 t e s t D a t a = f r o m f i l e ( t e s t I m a g e F i l e , d t y p e = u i n t 8 )
18 . r e s h a p e ( −1 , 7 8 4)
19 t e s t I m a g e F i l e . c l o s e ( )
20
21 t e s t L a b e l F i l e = open ( r ’ t e s t L a b e l ’ , ’ r b ’ )
22 t e s t L a b e l = f r o m f i l e ( t e s t L a b e l F i l e , d t y p e = u i n t 8 )
23 t e s t L a b e l F i l e . c l o s e ( )
24 r e t u r n t r a i n i n g D a t a , t r a i n i n g L a b e l , t e s t D a t a , t e s t L a b e l
25
26 d e f c r e a t e B i n D a t a ( t r a i n i n g D a t a , t r a i n i n g L a b e l ,
27 t e s t D a t a , t e s t L a b e l ) :
28 t r a i n i n g D a t a = ( 25 5 − t r a i n i n g D a t a ) / 2 5 5 . 0
29 s c a l e = random . random ( t r a i n i n g D a t a . s h a p e )
30 t r a i n i n g D a t a [ g r e a t e r ( t r a i n i n g D a t a , s c a l e ) ] = 1
31 t r a i n i n g D a t a [ l e s s e q u a l ( t r a i n i n g D a t a , s c a l e ) ] = 0
32 t r a i n i n g D a t a = u i n t 8 ( t r a i n i n g D a t a )
- 112 -
33 f p = open ( r ’ b i n T r a i n i n g D a t a 0 ’ , ’wb ’ )
34 f p . w r i t e ( t r a i n i n g D a t a )
35 f p . c l o s e ( )
36
37 t e s t D a t a = (2 5 5 − t e s t D a t a ) / 2 5 5 . 0
38 s c a l e = random . random ( t e s t D a t a . s h ap e )
39 t e s t D a t a [ g r e a t e r ( t e s t D a t a , s c a l e ) ] = 1
40 t e s t D a t a [ l e s s e q u a l ( t e s t D a t a , s c a l e ) ] = 0
41 t e s t D a t a = u i n t 8 ( t e s t D a t a )
42 f p = open ( r ’ b i n T e s t D a t a ’ , ’wb ’ )
43 f p . w r i t e ( t e s t D a t a )
44 f p . c l o s e ( )
45
46 d e f g e t B i n D a t a ( ) :
47 t r a i n i n g I m a g e F i l e = open ( r ’ b i n T r a i n i n g D a t a 0 ’ , ’ r b ’ )
48 t r a i n i n g D a t a = f r o m f i l e ( t r a i n i n g I m a g e F i l e , d t y p e= u i n t 8 )
49 . r e s h a p e ( −1 , 7 8 4)
50 t r a i n i n g I m a g e F i l e . c l o s e ( )
51
52 t r a i n i n g L a b e l F i l e = open ( r ’ t r a i n i n g L a b e l ’ , ’ r b ’ )
53 t r a i n i n g L a b e l = f r o m f i l e ( t r a i n i n g L a b e l F i l e , d t y p e= u i n t 8 )
54 t r a i n i n g L a b e l F i l e . c l o s e ( )
55
56 t e s t I m a g e F i l e = open ( r ’ b i n T e s t D a t a ’ , ’ r b ’ )
57 t e s t D a t a = f r o m f i l e ( t e s t I m a g e F i l e , d t y p e = u i n t 8 )
58 . r e s h a p e ( −1 , 7 8 4)
59 t e s t I m a g e F i l e . c l o s e ( )
60
61 t e s t L a b e l F i l e = open ( r ’ t e s t L a b e l ’ , ’ r b ’ )
62 t e s t L a b e l = f r o m f i l e ( t e s t L a b e l F i l e , d t y p e = u i n t 8 )
63 t e s t L a b e l F i l e . c l o s e ( )
64 r e t u r n d o u b l e ( t r a i n i n g D a t a ) , t r a i n i n g L a b e l ,
65 d o u b l e ( t e s t D a t a ) , t e s t L a b e l
- 113 -
哈尔滨工业大学本科毕业设计（论文）
66 d e f l o a d T r a i n i n g D a t a ( l a y e r , d i me n si o n ) :
67 f i le N a m e = ’ b i n T r a i n i n g D a t a ’ + s t r ( l a y e r )
68 f p = open ( f il eN ame , ’ r b ’ )
69 t r a i n i n g D a t a = f r o m f i l e ( fp , d t y p e = u i n t 8 )
70 . r e s h a p e ( −1 , d i me n s i o n )
71 f p . c l o s e ( )
72 r e t u r n t r a i n i n g D a t a
73
74 d e f c r e a t e I m a g e ( d a t a , imageName = ’ temp ’ , mode = ’ j p g ’ ,
75 t r a n s = True , showNow = F a l s e ) :
76 i f t r a n s == Tru e :
77 ima ge = 255 − d a t a
78 e l s e :
79 ima ge = d a t a
80 image . s ha p e = 2 8 , 28
81 imageName = imageName + ’ . ’ + mode
82 misc . im s ave ( imageName , image )
83 i f show Now == Tr u e :
84 ima ge = Image . open ( imageName )
85 ima ge . show ( )
86 d e f c r e a t e B i n I m a g e ( da t a , imageName = ’ temp ’ , mode = ’ j p g ’ ,
87 t r a n s = F a l s e , sh owNow = F a l s e ) :
88 i f t r a n s == Tru e :
89 ima ge = f l o a t 6 4 ( 1 − d a t a )
90 e l s e :
91 ima ge = f l o a t 6 4 ( d a t a )
92 image . s ha p e = 2 8 , 28
93 imageName = imageName + ’ . ’ + mode
94 misc . im s ave ( imageName , image )
95 i f show Now == Tr u e :
96 ima ge = Image . open ( imageName )
97 ima ge . show ( )
- 114 -
代码 A.3 RBM.py
1 i mport numpy a s np
2 i mport gnumpy a s GPU
3 from s c i p y i mport s t a t s
4 i mport s c i p y . weave a s weave
5 from MNISTData impor t ∗
6
7 c l a s s RBM:
8 d e f i n i t ( s e l f , l a y e r , v is Hi d , k =1 ,
9 l e a r n i n g R a t e = 0 . 0 0 1 , maxEpoch = 1 0 0 ,
10 l o a d P a r a m e t e r = F a l s e ) :
11 s e l f . l a y e r = l a y e r
12 s e l f . numVis = v i s H i d [ 0 ]
13 s e l f . numHid = v i s H i d [ 1 ]
14 s e l f . k = k
15 s e l f . l e a r n i n g R a t e = l e a r n i n g R a t e
16 s e l f . maxEpoch = maxEpoch
17 i f l o a d P a r a m e t e r == F a l s e :
18 p r i n t ” i n i t ” , s t r ( l a y e r )+ ” t h RBM’ s p a r a m e t e r s ”
19 Ga u s s i a n = s t a t s . norm ( 0 , 0 . 0 1 )
20 s e l f .W = np . a r r a y ( G a u s s i a n . r v s (
21 ( s e l f . numHid , s e l f . numVis ) ) , np . f l o a t 3 2 )
22 t r a i n i n g D a t a = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
23 s e l f . numVis )
24 p = np . mean ( t r a i n i n g D a t a , a x i s = 0 )
25 p = np . t r u e d i v i d e ( p , s u b t r a c t ( 1 . 0 0 0 1 , p ) )
26 s e l f . v i s B a i s = np . l o g ( p ) . r e s h a p e ( s e l f . numVis , 1 )
27 s e l f . h i d B a i s = np . z e r o s ( ( s e l f . numHid , 1 ) , d o u bl e )
28 s e l f . f e a t u r e E x t r a c t ( )
29 e l s e :
30 p r i n t ” l o a d ” , s t r ( l a y e r )+ ” t h RBM’ s p a r e m e t e r s ”
31 s e l f .W, s e l f . v i s B a i s , s e l f . h i d B a i s =
32 s e l f . l o a d P a r a m e t e r ( )
- 115 -
33 d e f t r a i n i n g ( s e l f ) :
34 from gnumpy import l o g i s t i c
35 de f s a mp le H id Giv en V is ( w eig h t , v t , h i d B a i s ) :
36 h = GPU . l o g i s t i c (GPU . d o t ( w ei g ht , v t ) + h i d B a i s )
37 hSample = h . r a n d ( ) < h
38 r e t u r n hSample
39 de f s a mp le V is Giv en H id ( w eig h t , h t , v i s B a i s ) :
40 v = GPU . l o g i s t i c (GPU . d o t ( w e i g h t . T , h t )+ v i s B a i s )
41 vSample = v . r a n d ( ) < v
42 r e t u r n vSample
43
44 S = l o a d T r a i n i n g D a t a ( s e l f . l a y e r , s e l f . numVis )
45 S = np . f l o a t 3 2 ( S )
46 maxBatch = 100
47 S . s h ap e = maxBatch , −1 , s e l f . numVis
48 momentum = 0 . 9
49 e t a = 0 . 0 0 1
50
51 f o r e p och i n r a n g e ( s e l f . maxEpoch ) :
52 w e i g h t = GPU . g a r r a y ( s e l f .W)
53 v i s B a i s = GPU . g a r r a y ( s e l f . v i s B a i s )
54 h i d B a i s = GPU . g a r r a y ( s e l f . h i d B a i s )
55 d e l t a W e i g h t = GPU . z e r o s ( w e i g h t . s h a p e )
56 d e l t a V i s B a i s = GPU . z e r o s ( s e l f . v i s B a i s . s h a p e )
57 d e l t a H i d B a i s = GPU . z e r o s ( s e l f . h i d B a i s . s h ap e )
58 f o r b a t c h i n r a n g e ( maxBatch ) :
59 v 0 = GPU . g a r r a y ( S [ b a t c h ] . T )
60 v t = GPU . g a r r a y ( S [ b a t c h ] . T )
61 f o r i i n r a n g e ( s e l f . k ) :
62 h t =s am p le Hi d Gi ve n Vi s ( we i ght , v t , h i d B a i s )
63 v t =s am p le Vi s Gi ve n Hi d ( we i ght , h t , v i s B a i s )
64 p r o b 0 = GPU . l o g i s t i c (GPU . d o t ( w e ig h t , v 0 )
65 + h i d B a i s )
- 116 -
66 p r o b t = GPU . l o g i s t i c (GPU . d o t ( w e igh t , v t )
67 + h i d B a i s )
68 d e l t a W e i g h t = momentum∗ d e l t a W e i g h t + e t a
69 ∗ (GPU . d o t ( p ro b 0 , v 0 . T )
70 − GPU . d o t ( p r o b t , v t . T ) )
71 d e l t a V i s B a i s = momentum∗ d e l t a V i s B a i s + e t a
72 ∗ ( v 0 . sum ( 1 ) − v t . sum ( 1 ) )
73 . r e s h a p e ( −1 , 1 )
74 d e l t a H i d B a i s = momentum∗ d e l t a H i d B a i s + e t a
75 ∗( p r o b 0 . sum (1) − p r o b t . sum ( 1 ) )
76 . r e s h a p e ( −1 , 1 )
77 w e i g h t += d e l t a W e i g h t / maxBatch
78 h i d B a i s += d e l t a H i d B a i s / maxBatch
79 v i s B a i s += d e l t a V i s B a i s / maxBatch
80 s e l f .W = w e i g h t . a s n u m p y a r r a y ( )
81 s e l f . v i s B a i s = v i s B a i s . a s n u m p y a r r a y ( )
82 s e l f . h i d B a i s = h i d B a i s . a s n u m p y a r r a y ( )
83 p r i n t epoch , ’ epoch c o m p l e t e ! ’
84 s e l f . s a v e P a r a m e t e r ( )
85 p r i n t ” t r a i n i n g ” , s t r ( s e l f . l a y e r )+ ” t h ” , ”RBM c o m p l e t e ”
86 s e l f . f e a t u r e E x t r a c t ( )
87
88 d e f s a v e P a r a m e t e r ( s e l f ) :
89 f p = open ( r ’ w e i g h t ’ + s t r ( s e l f . l a y e r ) , ’wb ’ )
90 f p . w r i t e ( s e l f .W)
91 f p . c l o s e ( )
92 f p = open ( r ’ v i s B a i s ’ + s t r ( s e l f . l a y e r ) , ’wb ’ )
93 f p . w r i t e ( s e l f . v i s B a i s )
94 f p . c l o s e ( )
95 f p = open ( r ’ h i d B a i s ’ + s t r ( s e l f . l a y e r ) , ’wb ’ )
96 f p . w r i t e ( s e l f . h i d B a i s )
97 f p . c l o s e ( )
98 p r i n t ” l a y e r ” , s e l f . l a y e r , ” p a r a m e t e r s had b e e n s a v e ”
- 117 -
99 d e f l o a d P a r a m e t e r ( s e l f ) :
100 f p = open ( r ’ w e ig h t ’ + s t r ( s e l f . l a y e r ) , ’ r b ’ )
101 w e i g h t = f r o m f i l e ( fp , d t y p e = d o u b l e )
102 . r e s h a p e ( s e l f . numHid , s e l f . numVis )
103 f p . c l o s e ( )
104 f p = open ( r ’ v i s B a i s ’ + s t r ( s e l f . l a y e r ) , ’ r b ’ )
105 v i s B a i s = f r o m f i l e ( fp , d t y p e = d o u b l e )
106 . r e s h a p e ( s e l f . numVis , 1 )
107 f p . c l o s e ( )
108 f p = open ( r ’ h i d B a i s ’ + s t r ( s e l f . l a y e r ) , ’ r b ’ )
109 h i d B a i s = f r o m f i l e ( fp , d t y p e = d o u b l e )
110 . r e s h a p e ( s e l f . numHid , 1 )
111 f p . c l o s e ( )
112 re tu r n we i ght , v i s B a i s , h i d B a i s
113
114 d e f f e a t u r e E x t r a c t ( s e l f , l o w F e a t u r e = None ) :
115 i f l o w F e a t u r e == None :
116 l o w F e a t u r e = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
117 s e l f . numVis )
118 numCase = l o w F e a t u r e . s h ap e [ 0 ]
119 h i g h F e a t u r e = z e r o s ( ( numCase , s e l f . numHid ) ,
120 d t y p e = u i n t 8 )
121 f o r c a s e i n r a n g e ( numCase ) :
122 p r ob = 1 . 0 / ( 1 + np . exp (
123 − np . d o t ( l o w F e a t u r e [ c a s e ] , s e l f .W. T )
124 − s e l f . h i d B a i s . T ) )
125 s c a l e = np . random . random ( p ro b . s h a p e )
126 temp = z e r o s ( p ro b . sh a pe , d t y p e = np . u i n t 8 )
127 temp [ l e s s ( s c a l e , p r ob ) ] = 1
128 h i g h F e a t u r e [ c a s e ] = temp
129
130 f il e N a m e = ’ b i n T r a i n i n g D a t a ’+ s t r ( s e l f . l a y e r +1)
131 f p = open ( f i leN a me , ’wb ’ )
- 118 -
哈尔滨工业大学本科毕业设计（论文）
132 f p . w r i t e ( h i g h F e a t u r e )
133 f p . c l o s e ( )
134 p r i n t ” h i g h f e a t u r e had be e n e x t r a c t e d ! ”
135 e l s e :
136 pr ob = 1 . 0 / ( 1 + np . exp ( −np . d o t ( l o w F e a t u r e , s e l f .W. T )
137 − s e l f . h i d B a i s . T ) )
138 r e t u r n p ro b
139
140 d e f r e c o n s t r u c t ( s e l f , h i g h F e a t u r e ) :
141 h i g h F e a t u r e . s h a pe = 1 , −1
142 pr o b = 1 . 0 / ( 1 + np . exp (−np . d o t ( h i g h F e a t u r e , s e l f .W)
143 − s e l f . v i s B a i s . T ) )
144 re tu r n p r ob
- 119 -
代码 A.4 softmax.py
1 from RBM impo rt ∗
2 from s c i p y . o dr . o d r p ac k import O ut pu t
3
4 c l a s s s o f t m a x (RBM) :
5 d e f i n i t ( s e l f , l a y e r , v is Hi d ,
6 l e a r n i n g R a t e = 0 . 0 0 1 , maxEpoch = 5 ,
7 l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . l a y e r = l a y e r
9 s e l f . numVis = v i s H i d [ 0 ]
10 s e l f . numHid = v i s H i d [ 1 ]
11 s e l f . l e a r n i n g R a t e = l e a r n i n g R a t e
12 s e l f . maxEpoch = maxEpoch
13 i f l o a d P a r a m e t e r == F a l s e :
14 p r i n t ” i n i t ” , s t r ( l a y e r )+ ” t h RBM’ s p a r a m e t e r s ”
15 G a u s s i a n = s t a t s . norm ( 0 , 0 . 0 1 )
16 s e l f .W = np . a r r a y ( G a u s s i a n . r v s (
17 ( s e l f . numHid , s e l f . numVis ) ) , d o u b l e )
18 t r a i n i n g D a t a = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
19 s e l f . numVis )
20 p = np . mean ( t r a i n i n g D a t a , a x i s = 0 )
21 p = np . t r u e d i v i d e ( p , s u b t r a c t ( 1 . 0 0 0 1 , p ) )
22 s e l f . v i s B a i s = np . l o g ( p ) . r e s h a p e ( s e l f . numVis , 1 )
23 s e l f . h i d B a i s = np . z e r o s ( ( s e l f . numHid , 1 ) , d o u bl e )
24 s e l f . s a v e P a r a m e t e r ( )
25 e l s e :
26 p r i n t ” l o a d ” , s t r ( l a y e r )+ ” t h RBM’ s p a r e m e t e r s ”
27 s e l f .W, s e l f . v i s B a i s , s e l f . h i d B a i s =
28 s e l f . l o a d P a r a m e t e r ( )
29 d e f t r a i n i n g ( s e l f ) :
30 G a u s s i an = s t a t s . norm ( 0 , 0 . 0 0 1 )
31 t r a i n i n g D a t a = l o a d T r a i n i n g D a t a ( s e l f . l a y e r ,
32 s e l f . numVis )
- 120 -
哈尔滨工业大学本科毕业设计（论文）
33 t r a i n i n g L a b e l = g e t B i n D a t a ( ) [ 1 ]
34 numCase = t r a i n i n g D a t a . s ha p e [ 0 ]
35 w e i g h t = np . a r r a y ( G a u s s i a n . r v s ( s i z e =( s e l f . numHid ,
36 s e l f . numVis + 1 ) ) ,
37 d t y p e = d o u b l e )
38 f o r e p och i n r a n g e ( s e l f . maxEpoch ) :
39 f o r i i n r a n g e ( numCase ) :
40 sa m ple = t r a i n i n g D a t a [ i ] . r e s h a p e ( −1 , 1 )
41 t a r g e t = t r a i n i n g L a b e l [ i ]
42 sa m ple = v s t a c k ( ( 1 , sa m pl e ) )
43 t a r g e t O u t = np . exp ( d o t ( w e igh t , s am pl e ) )
44 . r e s h a p e ( −1)
45 Z = sum ( t a r g e t O u t )
46 t a r g e t O u t = ( t a r g e t O u t / Z ) . r e s h a p e ( −1 , 1 )
47 d e l t a =−d o t ( t a r g e t O u t , sa mp le . r e s h a p e ( 1 , −1 ) )
48 d e l t a [ t a r g e t ] += s a mpl e . r e s h a p e ( −1 )
49 d e l t a += 0 . 0 0 5 ∗ w e i g h t
50 w e i g h t += 0 . 0 0 1 ∗ d e l t a
51 s e l f .W = copy ( w e i g h t [ : , 1 : ]
52 . r e s h a p e ( s e l f .W. s h a p e ) )
53 s e l f . h i d B a i s = copy ( w e i g h t [ : , 0 ] . r e s h a p e (
54 s e l f . h i d B a i s . s h a p e ) )
55 p r i n t epoch , ” c o m p l e t e ”
56 p r i n t ” t r a i n i n g ” , s t r ( s e l f . l a y e r )+ ” t h ” , ”RBM c o m p l e t e ”
57 s e l f . s a v e P a r a m e t e r ( )
58
59 d e f f e a t u r e E x t r a c t ( s e l f , l o w F e a t u r e ) :
60 pr o b=np . exp ( d o t ( l o w F e a t u r e , s e l f .W. T)+ s e l f . h i d B a i s . T )
61 Z = sum ( p r ob )
62 pr o b = ( p r ob / Z )
63 re tu r n p r ob
- 121 -
代码 A.5 DBNs.py
1 from numpy import ∗
2 from RBM impo rt ∗
3 from s of t ma x import ∗
4 from MNISTData impor t ∗
5
6 c l a s s DBNs :
7 d e f i n i t ( s e l f , no deNum , l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . r bm P ai r = z i p ( nodeNum [ : −1 ] , nodeNum [ 1 : ] )
9 rb msNum = l e n ( nodeNum ) − 1
10 s e l f . rbms = [ None f o r i i n r a n g e ( rbmsNum ) ]
11 i f l o a d P a r a m e t e r == T ru e :
12 f o r i i n r a n g e ( rbmsNum ) :
13 i f i != rbmsNum − 1 :
14 s e l f . rbms [ i ] = RBM( i , s e l f . r bm P ai r [ i ] ,
15 l o a d P a r a m e t e r = True )
16 e l s e :
17 s e l f . rbms [ i ]= s o f t m a x ( i , s e l f . r b m P a i r [ i ] ,
18 l o a d P a r a m e t e r = True )
19 e l s e :
20 f o r i i n r a n g e ( rbmsNum ) :
21 i f i != rbmsNum − 1 :
22 s e l f . rbms [ i ] = RBM( i , s e l f . r b m P a i r [ i ] )
23 e l s e :
24 s e l f . rbms [ i ]= s o f t m a x ( i , s e l f . r b m P a i r [ i ] )
25
26 d e f p r e T r a i n i n g ( s e l f ) :
27 f o r rbm i n s e l f . rbms :
28 rbm . t r a i n i n g ( )
29 p r i n t ”DBNs had pr e −t r a i n e d c o m p l e t e ! ”
30
31
32
- 122 -
33 d e f f i n e T u n i n g ( s e l f , maxEpoch = 1 0 ) :
34 import gnumpy a s GPU
35 de f makeBatch ( maxBatch = 1 0 0 ) :
36 t r a i n i n g D a t a = (255 − g e t D a t a ( ) [ 0 ] ) / 2 5 5 . 0
37 t r a i n i n g D a t a = g e t B i n D a t a ( ) [ 0 ]
38 t r a i n i n g D a t a = h s t a c k (
39 ( o ne s ( ( t r a i n i n g D a t a . s h a pe [ 0 ] , 1 ) ) ,
40 t r a i n i n g D a t a ) )
41 l a b e l = g e t B i n D a t a ( ) [ 1 ]
42 t r a i n i n g L a b e l = np . z e r o s ( ( numCase , 1 0 ) )
43 t r a i n i n g L a b e l [ [ i f o r i i n r a n g e ( numCase ) ] ,
44 l a b e l ] = 1
45 r e t u r n t r a i n i n g D a t a . r e s h a p e ( maxBatch , −1 , 7 8 5 ) ,
46 t r a i n i n g L a b e l . r e s h a p e ( maxBatch , −1 ,10 ) ,
47
48 de f g e t A b s t r a c t ( we i gh t , i n p u t ) :
49 pr ob = [ i n p u t ]
50 f o r W i n we i g h t [ : −1 ] :
51 temp = GPU . d o t ( p ro b [ −1 ] , W. T ) . l o g i s t i c ( )
52 temp = h s t a c k ( ( o n es ( ( temp . s ha p e [ 0 ] , 1 ) ) ,
53 temp . a s n u m p y a r r a y ( ) ) )
54 p r ob . append (GPU . g a r r a y ( temp ) )
55 o u t p u t =GPU . exp (GPU . d o t ( p ro b [ −1 ] , w e i gh t [ −1 ] . T ) )
56 Z = GPU . sum ( o u t p u t , a x i s = 1 ) . r e s h a p e ( −1 , 1 )
57 o u t p u t = o u t p u t / Z
58 pr ob . r e v e r s e ( )
59 r e t u r n prob , o u t p u t
60 de f weight2GPU ( ) :
61 w e i g h t = [ ]
62 f o r rbm i n s e l f . rbms :
63 temp=GPU . g a r r a y ( h s t a c k ( ( rbm . h i d B a i s , rbm .W) ) )
64 w e i g h t . ap p e n d ( temp )
65 r e t u r n we i g h t
- 123 -
66 p r i n t ” s t a r t t o f i n e t u n i n g ”
67 maxEpoch = 200
68 maxBatch = 300
69 t r a i n i n g D a t a , t r a i n i n g L a b e l = makeBatch ( maxBatch )
70 numCase = t r a i n i n g D a t a . s ha p e [ 1 ]
71 w e i g h t = weight2GPU ( )
72 e p s i l o n = 0. 9 9 9
73 l e a r n i n g R a t e = 0 . 1
74 t r a i n i n g D a t a = GPU . g a r r a y ( t r a i n i n g D a t a )
75 t r a i n i n g L a b e l = GPU . g a r r a y ( t r a i n i n g L a b e l )
76 f o r e p och i n r a n g e ( maxEpoch ) :
77 s e l f . r e c o g n i z e ( )
78 f o r i i n r a n g e ( maxBatch ) :
79 i n p u t = t r a i n i n g D a t a [ i ]
80 t a r g e t = t r a i n i n g L a b e l [ i ]
81 prob , o u t p u t = g e t A b s t r a c t ( w e igh t , i n p u t )
82 s e n s = t a r g e t − o u t p u t
83 w e i g h t . r e v e r s e ( )
84 f o r W, X, i n d e x i n z i p ( w e igh t , prob ,
85 r a n g e ( l e n ( w e ig h t ) ) ) :
86 d e l t a = GPU . d o t ( s e n s . T , X)
87 s e n s = GPU . d o t ( se ns , W) ∗ X ∗ ( 1 − X)
88 s e n s = s e n s [ : , 1 : ]
89 w e i g h t [ i n d e x ] += l e a r n i n g R a t e ∗ d e l t a
90 / ( numCase )
91 w e i g h t . r e v e r s e ( )
92 p r i n t epoch , ” c o m p l e t e ! ”
93 f o r rbm , W i n z i p ( s e l f . rbms , w e i g h t ) :
94 rbm .W = ( e p s i l o n ∗W[ : , 1 : ] ) . a s n u m p y a r r a y ( )
95 rbm . h i d B a i s = W[ : , 0 ] . a s n u m p y a r r a y ( )
96 f o r rbm i n ( s e l f . rbms ) :
97 rbm . s a v e P a r a m e t e r ( )
98
- 124 -
99 d e f r e c o n s t r u c t ( s e l f , numCase =100 , t r a i n i n g D a t a =None ) :
100 i f t r a i n i n g D a t a == None :
101 t r a i n i n g D a t a = g e t B i n D a t a ( ) [ 0 ]
102 pureRBM = s e l f . rbms [ : −1 ]
103 f o r i i n r a n g e ( numCase ) :
104 sa m ple = t r a i n i n g D a t a [ i ]
105 a b s t r a c t = s a mpl e
106 f o r rbm i n pureRBM :
107 a b s t r a c t = rbm . f e a t u r e E x t r a c t ( a b s t r a c t )
108 p ureRB M . r e v e r s e ( )
109 f o r rbm i n pureRBM :
110 a b s t r a c t = rbm . r e c o n s t r u c t ( a b s t r a c t )
111 p ureRB M . r e v e r s e ( )
112 imageName = ’ r e c o n s t r u c t ’ + s t r ( i )
113 c r e a t e I m a g e ( 2 55 ∗ a b s t r a c t , imageName ,
114 showNow = F a l s e , t r a n s = F a l s e )
115 e l s e :
116 pureRBM = s e l f . rbms [ : −1 ]
117 a b s t r a c t = t r a i n i n g D a t a
118 f o r rbm i n pureRBM :
119 a b s t r a c t = rbm . f e a t u r e E x t r a c t ( a b s t r a c t )
120 pureRBM . r e v e r s e ( )
121 f o r rbm i n pureRBM :
122 a b s t r a c t = rbm . r e c o n s t r u c t ( a b s t r a c t )
123 s c a l e = np . random . random ( a b s t r a c t . s h a pe )
124 temp = z e r o s ( a b s t r a c t . s h a p e )
125 temp [ l e s s ( s c a l e , a b s t r a c t ) ] = 1
126 c r e a t e I m a g e ( 2 55 ∗ a b s t r a c t ,
127 showNow = F a l s e , t r a n s = F a l s e )
128 r e t u r n temp
129
130
131
- 125 -
哈尔滨工业大学本科毕业设计（论文）
132 d e f r e c o g n i z e ( s e l f , t e s t D a t a = None , t e s t L a b e l = None ) :
133 i f t e s t D a t a == None or t e s t L a b e l == None :
134 t e s t D a t a = (255 − g e t D a t a ( ) [ 2 ] ) / 2 5 5 . 0
135 # t e s t D a t a = g e t B i n D a t a ( ) [ 2 ]
136 t e s t L a b e l = g e t B i n D a t a ( ) [ 3 ]
137 numCase = t e s t D a t a . s h a pe [ 0 ]
138 maxBatch = 100
139 t e s t D a t a . s h a pe = maxBatch , −1 , 784
140 t e s t L a b e l . s h a pe = maxBatch , −1
141 e l s e :
142 numCase = t e s t D a t a . s h a pe [ 0 ] ∗ t e s t D a t a . s ha p e [ 1 ]
143 maxBatch = t e s t D a t a . s h a pe [ 0 ]
144
145 c o u n t = 0
146 f o r i i n r a n g e ( maxBatch ) :
147 i n p u t = t e s t D a t a [ i ]
148 o u t p u t = i n p u t
149 f o r rbm i n s e l f . rbms :
150 o u t p u t = rbm . f e a t u r e E x t r a c t ( o u t p u t )
151 g u e s t = argmax ( o u t p u t , a x i s = 1 )
152 b in g o = g u e s t == t e s t L a b e l [ i ]
153 c o u n t += sum ( b i n go )
154 p r i n t ” c o r r e c t r a t e =” , s t r ( 1 0 0 . 0 ∗ c o u n t / numCase )+ ”%”
- 126 -
哈尔滨工业大学本科毕业设计（论文）
附录 B 卷积神经网络源代码
在本附录中给出CIFAR中使用的卷积神经网络源代码，由于MNIST源代码与
这里类似，只是构造器有略微的不同，因此我们不打算提供MNIST中卷积网络的
代码，读者可经过很少的改动便可将以下的代码改写成训练MNIST数据集的代码。
在这几个文件中，Main.py是整个程序的入口。CIFAR.py是工具文件，它提供获取
数据集以及绘制图像的功能。FormatLayer.py是最顶层特征图展开成列向量所经过
的一个格式转化层。CNNs.py是整个卷积网络的类文件，它能实现网络的前向传
播和反向传播。SubsamplingLayer.py是采样层类文件。ConvLayer.py是卷积层类文
件。FullConnectLayer.py是全连接层的类文件。可以看到，整个网络的代码已经被
我们写成紧耦合的了，我们没有时间将这些代码写成松耦合形式，有兴趣的读者
可进行尝试。另外，鉴于版面的问题，我们对代码的格式进行了调整，因此直接
拷贝这些代码是不会执行的，你需要再重新调整他们的格式。我们对数据集进行
了镜像处理，因此我们总共有10个批次的数据集，进行图像镜像仅仅只是将矩阵
翻转，很容易实现，所以在这里我们就不贴代码了。
代码 B.1 FormatLayer.py
1 from CNNs impo rt ∗
2 cnn = CNNs ( l o a d = F a l s e )
3 cnn . t r a i n ( )
4 c o r r e c t R a t e = cnn . t e s t i n g ( )
5 p r i n t c o r r e c t R a t e
- 127 -
哈尔滨工业大学本科毕业设计（论文）
代码 B.2 CIFAR.py
1 from numpy import ∗
2 from s c i p y i mport mi s c
3 i mport Image
4
5 d e f u n p i c k l e ( f i l e ) :
6 imp ort c P i c k l e
7 f o = open ( f i l e , ’ r b ’ )
8 d i c t = c P i c k l e . l o a d ( f o )
9 f o . c l o s e ( )
10 r e t u r n d i c t [ ’ d a t a ’ ] , a r r a y ( d i c t [ ’ l a b e l s ’ ] )
11
12 d e f g e t D a t a ( i ) :
13 f i le N a m e = ’ d a t a b a t c h ’ + s t r ( i )
14 t r a i n i n g D a t a , t r a i n i n g L a b e l = u n p i c k l e ( f i l e Na m e )
15 r e t u r n t r a i n i n g D a t a / 2 5 5 . 0 , t r a i n i n g L a b e l
16
17 d e f g e t T e s t D a t a ( ) :
18 f i le N a m e = ’ t e s t b a t c h ’
19 t e s t D a t a , t e s t L a b e l = u n p i c k l e ( f i le Na m e )
20 r e t u r n t e s t D a t a / 2 5 5 . 0 , t e s t L a b e l
21
22 d e f c r e a t e I m a g e ( d a t a , imageName = ’ temp ’ , mode = ’ j p g ’ ) :
23 r e d = d a t a [ : 1 0 2 4 ]
24 g r e e n = d a t a [ 1 0 2 4 : 2 0 4 8 ]
25 b l u e = d a t a [ 2 0 4 8 : ]
26 image = a r r a y ( z i p ( red , gr ee n , b l u e ) ) . r e s h a p e ( 3 2 , 3 2 , 3 )
27 imageName = imageName + ’ . ’ + mode
28 misc . im s ave ( imageName , image )
- 128 -
代码 B.3 CNNs.py
1 from ConvLayer import ∗
2 from S u b sa m p l in g L a ye r impo rt ∗
3 from F u l l C o n n e c t L a y e r imp ort ∗
4 i mport numpy a s np
5 from CI FAR i mport ∗
6 from Fo rm a t L ay er import ∗
7
8 c l a s s CNNs ( ) :
9
10 d e f i n i t ( s e l f , l o a d = F a l s e ) :
11 s e l f .CNN = [ ConvLayer ( 1 , 3 , 9 , l o a d P a r a m e t e r = l o a d ) ,
12 S u b s a mp l i n gL a y e r ( 2 ) ,
13 Fo r m a tL ay e r ( 6 , 9 , 1 4 , 1 4 ) ,
14 F u l l C o n n e c t L a y e r ( 7 , 17 6 4 , 1 0 ,
15 l o a d P a r a m e t e r = l o a d ) ]
16
17 d e f t r a i n i n g ( s e l f ) :
18 f o r i i n r a n g e ( 4 0 0 ) :
19 s e l f . t r a i n A e p o c h ( )
20 c o r r e c t R a t e = s e l f . t e s t ( ) / 1 0 0 . 0
21 p r i n t ’ e p o c h ’ , i , ’ c o m p l e t e ’ ,
22 ’ c o r r e c t r a t e = ’ , c o r r e c t R a t e
23 f o r l a y e r i n s e l f .CNN:
24 l a y e r . s a v e P a r a m e t e r ( )
25
26
27 d e f t r a i n A e p o c h ( s e l f ) :
28 e r r o r = 0
29 f o r b a t c h i n r a n g e ( 1 0 ) :
30 numCase = 10000
31 t r a i n i n g D a t a = g e t D a t a ( b a t c h + 1 ) [ 0 ] [ : numCase ]
32 l a b e l = g e t D a t a ( b a t c h + 1 ) [ 1 ] [ : numCase ]
- 129 -
33 t r a i n i n g L a b e l = np . z e r o s ( ( numCase , 1 0 ) )
34 t r a i n i n g L a b e l [ [ i f o r i i n r a n g e ( numCase ) ] ,
35 l a b e l ] = 1
36
37 f o r i i n r a n g e ( numCase ) :
38 r e d = t r a i n i n g D a t a [ i ] [ : 1 0 2 4 ]
39 . r e s h a p e ( 3 2 , 32 )
40 g r e e n = t r a i n i n g D a t a [ i ] [ 1 0 2 4 : 2 0 4 8 ]
41 . r e s h a p e ( 3 2 , 32 )
42 b l u e = t r a i n i n g D a t a [ i ] [ 2 0 4 8 : ]
43 . r e s h a p e ( 3 2 , 32 )
44 f e a t u r e M a p = [ r e d , g r ee n , b l u e ]
45 temp = [ f e a t u r e M a p ]
46 # f p r o p
47 f o r l a y e r i n s e l f .CNN:
48 f e a t u r e M a p = l a y e r . f p r o p ( f e a t u r e M a p )
49 temp . i n s e r t ( 0 , f e a t u r e M a p )
50 # c l a c e r r o r
51 o u t I n = z i p ( temp [ : −1 ] , temp [ 1 : ] )
52 g u e s t = temp [ 0 ]
53 l o s e F u n c D i f f A c t = g u e s t
54 − t r a i n i n g L a b e l [ i ] . r e s h a p e ( −1 , 1 )
55 e r r o r += np . d o t ( l o s e F u n c D i f f A c t . T ,
56 l o s e F u n c D i f f A c t )
57 s e l f .CNN . r e v e r s e ( )
58 # b p ro b
59 f o r l a y e r , o u t I n i n z i p ( s e l f .CNN [ : ] ,
60 o u t I n [ : ] ) :
61 l o s e F u n c D i f f A c t = l a y e r . b p ro p (
62 l o s e F u n c D i f f A c t ,
63 o u t I n [ 1 ] , o u t I n [ 0 ] )
64 s e l f .CNN . r e v e r s e ( )
65 p r i n t ’ a b a t c h co mp le t e , e r r o r = ’ , e r r o r
- 130 -
哈尔滨工业大学本科毕业设计（论文）
66 d e f t e s t i n g ( s e l f ) :
67 t e s t D a t a = g e t T e s t D a t a ( ) [ 0 ]
68 t e s t L a b e l = g e t T e s t D a t a ( ) [ 1 ]
69 numCase = 10000
70 h i t = 0
71 f o r i i n r a n g e ( numCase ) :
72 r e d = t e s t D a t a [ i ] [ : 1 0 2 4 ] . r e s h a p e ( 3 2 , 32 )
73 g r e e n = t e s t D a t a [ i ] [ 1 0 2 4 : 2 0 4 8 ] . r e s h a p e ( 3 2 , 3 2)
74 b l u e = t e s t D a t a [ i ] [ 2 0 4 8 : ] . r e s h a p e ( 3 2 , 3 2 )
75 f e a t u r e = [ r e d , g r ee n , b l u e ]
76 f o r l a y e r , l a y e r I n d e x i n z i p ( s e l f . CNN,
77 r a n g e ( l e n ( s e l f .CNN ) ) ) :
78 f e a t u r e = l a y e r . f p r o p ( f e a t u r e )
79 g u e s t = np . argmax ( f e a t u r e )
80 l a b e l = t e s t L a b e l [ i ]
81 i f g u e s t == l a b e l :
82 h i t += 1
83 re tu r n h i t
- 131 -
代码 B.4 ConvLayer.py
1 i mport numpy a s np
2 from s c i p y . s i g n a l im port c o nv o l v e 2 d
3 from s c i p y i mport s t a t s
4
5 c l a s s ConvLayer ( ) :
6 d e f i n i t ( s e l f , l a y e r , inputMapNum , outputMapNum ,
7 k e r n e l S i z e =( 5 , 5 ) , l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . l a y e r = l a y e r
9 s e l f . inputMapNum = inputMapNum
10 s e l f . outputMapNum = outputMapNum
11 s e l f . k e r n e l S i z e = k e r n e l S i z e
12 G a u s s i a n = s t a t s . norm ( 0 , 0 . 0 0 0 1 )
13 s e l f . k e r n e l = [ [ None f o r j i n r a n g e ( s e l f . outputMapNum ) ]
14 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
15 i f l o a d P a r a m e t e r == F a l s e :
16 s e l f . k e r n e l = [ [ np . a r r a y ( G a u s s i a n . r v s ( k e r n e l S i z e ) )
17 f o r j i n r a n g e ( s e l f . outputMapNum ) ]
18 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
19 s e l f . b i a s = np . a r r a y ( [ np . random . random ( )
20 f o r i i n r a n g e ( s e l f . outputMapNum ) ] )
21 e l s e :
22 f o r i i n r a n g e ( s e l f . inputMapNum ) :
23 f o r j i n r a n g e ( s e l f . outputMapNum ) :
24 f p = open ( r ’ k e r n e l ’ + s t r ( s e l f . l a y e r )
25 + ’ ( ’+ s t r ( i )+ ’ , ’+ s t r ( j )+ ’ ) ’ , ’ r b ’ )
26 s e l f . k e r n e l [ i ] [ j ] = np . f r o m f i l e ( fp ,
27 dt y p e=np . d o u b l e )
28 . r e s h a p e ( s e l f . k e r n e l S i z e )
29 f p . c l o s e ( )
30 f p = open ( r ’ b i a s ’ + s t r ( s e l f . l a y e r ) , ’ r b ’ )
31 s e l f . b i a s = np . f r o m f i l e ( fp , d t y p e=np . d o u b l e )
32 f p . c l o s e ( )
- 132 -
33 p r i n t ” conv l a y e r ” , s e l f . l a y e r ,
34 ” p a r a m e t e r s had b e e n l o a d e d . ”
35 s e l f . l e a r n i n g R a t e = 0 . 0 1
36
37 d e f s a v e P a r a m e t e r ( s e l f ) :
38 f o r i i n r a n g e ( s e l f . inputMapNum ) :
39 f o r j i n r a n g e ( s e l f . outputMapNum ) :
40 f p = open ( r ’ k e r n e l ’ + s t r ( s e l f . l a y e r )
41 + ’ ( ’+ s t r ( i )+ ’ , ’+ s t r ( j )+ ’ ) ’ , ’wb ’ )
42 f p . w r i t e ( s e l f . k e r n e l [ i ] [ j ] )
43 f p . c l o s e ( )
44 f p = open ( r ’ b i a s ’ + s t r ( s e l f . l a y e r ) , ’wb ’ )
45 f p . w r i t e ( np . a r r a y ( s e l f . b i a s ) )
46 f p . c l o s e ( )
47 p r i n t ” conv l a y e r ” , s e l f . l a y e r ,
48 ” p a r a m e t e r s had be en s av e . ”
49
50 d e f conv ( s e l f , d a t a , k e r n e l ) :
51 f e a t u r e M a p = c o n vo l ve 2 d ( d a t a , k e r n e l , mode= ’ v a l i d ’ )
52 re tu r n f e a t u r e M a p
53
54 d e f f p r o p ( s e l f , i np u tM a ps ) :
55 h i g h F e a t u re M a p s = [ np . z e r o s l i k e (
56 s e l f . conv ( in p ut Map s [ 0 ] ,
57 s e l f . k e r n e l [ 0 ] [ 0 ] ) )
58 f o r i i n r a n g e ( s e l f . outputMapNum ) ]
59
60 f o r inputMap , k e r n e l i i n z i p ( in p u t Map s , s e l f . k e r n e l ) :
61 ou tp u tM a ps = [ s e l f . conv ( inputMap , k e r n e l j )
62 f o r k e r n e l j i n k e r n e l i ]
63 f o r i , outputM a p i n z i p ( r a n g e ( s e l f . outputMapNum ) ,
64 ou tp ut M ap s ) :
65 h i g h F e a t u r e M a p s [ i ] += o u t p u tMap
- 133 -
66
67 f o r i i n r a n g e ( s e l f . outputMapNum ) :
68 h i g h F e a t u r e M a p s [ i ] = 1 . 0 / ( 1
69 + np . exp (−h i g h F e a t u r e M a p s [ i ]
70 − s e l f . b i a s [ i ] ) )
71 re tu r n h i g h F e a t u r e M a p s
72
73 d e f bp ro p ( s e l f , l os sD i f f A c tM ap , inputMap , outputM a p ) :
74 de f r o t 1 8 0 ( M a t r i x ) :
75 r e t u r n np . r o t 9 0 ( M a tri x , 2 )
76
77 a c t Di f f N et M a p = [ o u t p u t ∗ ( 1 − o u t p u t )
78 f o r o u t p u t i n ou t p utMa p ]
79
80 sensMap = [ l o s s D i f f A c t ∗ a c t D i f f N e t
81 f o r l o s s D i f f A c t , a c t D i f f N e t i n
82 z i p ( l o ss Di f f A c t Ma p , a c tD i f f Ne t M a p ) ]
83
84 d e l t a K e r n e l = [ [ None f o r j i n r a n g e ( s e l f . outputMapNum ) ]
85 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
86
87 f o r i i n r a n g e ( s e l f . inputMapNum ) :
88 f o r j i n r a n g e ( s e l f . outputMapNum ) :
89 d e l t a K e r n e l [ i ] [ j ] = r o t 1 8 0 ( s e l f . conv (
90 inputMap [ i ] ,
91 r o t 1 8 0 ( sensMap [ j ] ) ) )
92 s e l f . k e r n e l [ i ] [ j ] −= s e l f . l e a r n i n g R a t e
93 ∗ d e l t a K e r n e l [ i ] [ j ]
94
95 f o r j i n r a n g e ( s e l f . outputMapNum ) :
96 s e l f . b i a s [ j ] −= s e l f . l e a r n i n g R a t e
97 ∗ np . sum ( sensMap [ j ] )
98
- 134 -
哈尔滨工业大学本科毕业设计（论文）
99 an s = [ np . z e r o s l i k e ( i n p u t M a p [ 0 ] )
100 f o r i i n r a n g e ( s e l f . inputMapNum ) ]
101 f o r i i n r a n g e ( s e l f . inputMapNum ) :
102 f o r j i n r a n g e ( s e l f . outputMapNum ) :
103 a ns [ i ] += c o n v o lv e 2 d ( sensMap [ j ] ,
104 r o t 1 8 0 ( s e l f . k e r n e l [ i ] [ j ] ) ,
105 mode= ’ f u l l ’ )
106 re tu r n a ns
- 135 -
哈尔滨工业大学本科毕业设计（论文）
代码 B.5 SubsamplingLayer.py
1 i mport numpy a s np
2 from s c i p y . s i g n a l im port c o nv o l v e 2 d
3 from s c i p y . l i n a l g import k ro n
4
5 c l a s s S ub s a m pl i n g La y e r ( ) :
6
7 d e f i n i t ( s e l f , l a y e r ) :
8 s e l f . l a y e r = l a y e r
9 s e l f . k e r n e l = 0 . 2 5 ∗ np . o n es ( ( 2 , 2 ) )
10
11 d e f s u b s a m p l i n g ( s e l f , d a t a ) :
12 f e a t u r e M a p = c o n vo l ve 2 d ( d a t a , s e l f . k e r n e l ,
13 mode= ’ v a l i d ’ )
14 re tu r n f e a t u r e M a p [ : : 2 , : : 2 ]
15
16 d e f s a v e P a r a m e t e r ( s e l f ) :
17 p r i n t ’ s u b s a m p l i n t l a y e r h as no p a r a m e t e r t o s a v e ’
18
19 d e f f p r o p ( s e l f , l owF ea t ur e Ma p s ) :
20 h i g h F e a t u re M a p s = [ s e l f . s u b s a m p l i n g ( d a t a )
21 f o r d a t a in l o wF e at u re M ap s ]
22 re tu r n h i g h F e a t u r e M a p s
23
24 d e f bp ro p ( s e l f , l os sD i f f A c tM ap , inputMap , outputM a p ) :
25 I2 x 2 = 0 . 2 5 ∗ np . on es ( ( 2 , 2 ) )
26 re tu r n [ k r on ( s en s , I 2x 2 ) f o r s e n s in l o s s D i f f A ct M a p ]
- 136 -
哈尔滨工业大学本科毕业设计（论文）
代码 B.6 FormatLayer.py
1 i mport numpy a s np
2 c l a s s F o rm at La y e r ( ) :
3 d e f i n i t ( s e l f , l a y e r , mapNum , mapRow , mapCol ) :
4 s e l f . mapNum = mapNum
5 s e l f . mapRow = mapRow
6 s e l f . mapCol = mapCol
7 s e l f . l a y e r = l a y e r
8
9 d e f f p r o p ( s e l f , d a t a ) :
10 re tu r n np . a r r a y ( d a t a ) . r e s h a p e ( ( −1 , 1 ) )
11
12 d e f s a v e P a r a m e t e r ( s e l f ) :
13 p r i n t ’ f o r m a t l a y e r h as no p a r a m e t e r t o s a v e ’
14
15 d e f bp ro p ( s e l f , l o s s D i f f A c t , f e e d I n , o u t p u t ) :
16 l o s s D i f f A c t . s h ap e = s e l f . mapNum , s e l f . mapRow ,
17 s e l f . mapCol
18 re tu r n [ maps f o r maps i n l o s s D i f f A c t ]
- 137 -
代码 B.7 FullConnectLayer.py
1 from s c i p y i mport s t a t s
2 i mport numpy a s np
3
4 c l a s s F u l l C o n n e c t L a y e r ( ) :
5
6 d e f i n i t ( s e l f , l a y e r , visNum , hidNum ,
7 l o a d P a r a m e t e r = F a l s e ) :
8 s e l f . l a y e r = l a y e r
9 G a u s s i an = s t a t s . norm ( 0 , 0 . 0 1 )
10 i f l o a d P a r a m e t e r == F a l s e :
11 s e l f . w e i g h t = np . a r r a y ( G a u s s i a n . r v s (
12 ( hidNum , visNum ) ) )
13 s e l f . b i a s = np . z e r o s ( ( hidNum , 1 ) )
14 e l s e :
15 f p = open ( r ’ w e i g h t ’ + s t r ( s e l f . l a y e r ) , ’ r b ’ )
16 s e l f . w e i g h t = np . f r o m f i l e ( fp , d t y p e = np . d o u b l e )
17 . r e s h a p e ( hidNum , visNum )
18 f p . c l o s e ( )
19 f p = open ( r ’ b i a s ’ + s t r ( s e l f . l a y e r ) , ’ r b ’ )
20 s e l f . b i a s = np . f r o m f i l e ( fp , d t y p e = np . d o u b l e )
21 . r e s h a p e ( hidNum , 1 )
22 f p . c l o s e ( )
23 p r i n t ” f u l l c o n n e c t l a y e r ” , s e l f . l a y e r ,
24 ” p a r a m e t e r s had b e e n l o a d e d . ”
25 s e l f . l e a r n i n g R a t e = 0 . 0 0 1
26
27 d e f s a v e P a r a m e t e r ( s e l f ) :
28 f p = open ( r ’ w e i g h t ’ + s t r ( s e l f . l a y e r ) , ’wb ’ )
29 f p . w r i t e ( s e l f . w e i g h t )
30 f p . c l o s e ( )
31 f p = open ( r ’ b i a s ’ + s t r ( s e l f . l a y e r ) , ’wb ’ )
32 f p . w r i t e ( s e l f . b i a s )
- 138 -
哈尔滨工业大学本科毕业设计（论文）
33 f p . c l o s e ( )
34 p r i n t ” f u l l c o n n e c t l a y e r ” , s e l f . l a y e r ,
35 ” p a r a m e t e r s had be en s av e . ”
36
37 d e f f p r o p ( s e l f , d a t a ) :
38 n e t = np . d o t ( s e l f . w e ig h t , d a t a ) + s e l f . b i a s
39 f e a t u r e = 1 . 0 / ( 1 + np . exp ( −n e t ) )
40 re tu r n f e a t u r e
41
42
43 d e f bp ro p ( s e l f , l o s s D i f f A c t , f e e d I n , o u t p u t ) :
44 a c t D i f f N e t = o u t p u t ∗ ( 1 − o u t p u t )
45 s e n s = l o s s D i f f A c t ∗ a c t D i f f N e t
46 d e l t a W e i g h t = np . d o t ( s en s , f e e d I n . T )
47 s e l f . w e i g h t −= s e l f . l e a r n i n g R a t e ∗ d e l t a W e i g h t
48 s e l f . b i a s −= s e l f . l e a r n i n g R a t e ∗ s e n s
49 re tu r n np . d o t ( s e l f . w e i g h t . T , s e n s )
- 139 -
